}).collect(Collectors.joining(","));
            buf.append(json);
            buf.append('}');
        } else if (value instanceof Long || value instanceof Integer) {
            buf.append(((Number) value).longValue());
        } else if (value instanceof Number) {
            buf.append(((Number) value).doubleValue());
        } else {

        // Assert correct index was used
        assertEquals("fess.update", deleteIndex);

        // Assert query builder is correct
        assertNotNull(deleteQuery);
        assertTrue(deleteQuery instanceof RangeQueryBuilder);
        RangeQueryBuilder rangeQuery = (RangeQueryBuilder) deleteQuery;
        assertEquals("expires", rangeQuery.fieldName());
        assertEquals("now", rangeQuery.to());

    Set<String> keySet = map.keySet();
    assertTrue(keySet instanceof SynchronizedSet);
    assertThat(((SynchronizedSet<?>) keySet).mutex).isSameInstanceAs(mutex);
  }

  public void testValues() {
    Map<String, Integer> map = create();
    Collection<Integer> values = map.values();
    assertTrue(values instanceof SynchronizedCollection);

  }

  @Override
  public boolean contains(@Nullable Object object) {
    return delegate.contains(object);
  }

  @Override
  public boolean containsAll(Collection<?> collection) {
    if (collection instanceof ImmutableEnumSet<?>) {
      collection = ((ImmutableEnumSet<?>) collection).delegate;
    }
    return delegate.containsAll(collection);
  }

  @Override
  public boolean isEmpty() {

      return satisfies(key, value);
    }
  }

  static <E extends @Nullable Object> Collection<E> filterCollection(
      Collection<E> collection, Predicate<? super E> predicate) {
    if (collection instanceof Set) {
      return Sets.filter((Set<E>) collection, predicate);
    } else {
      return Collections2.filter(collection, predicate);
    }
  }

  @Override

            }
            buf.append('}');
        } else if (obj instanceof Integer || obj instanceof Long || obj instanceof Float || obj instanceof Double) {
            buf.append(obj);
        } else if (obj instanceof Boolean) {
            buf.append(obj.toString());
        } else if (obj instanceof Date) {

  }

  @Override
  public boolean contains(@Nullable Object object) {
    return delegate.contains(object);
  }

  @Override
  public boolean containsAll(Collection<?> collection) {
    if (collection instanceof ImmutableEnumSet<?>) {
      collection = ((ImmutableEnumSet<?>) collection).delegate;
    }
    return delegate.containsAll(collection);
  }

  @Override
  public boolean isEmpty() {

   * they are returned by the iterable's iterator.
   *
   * @since 12.0
   */
  public static <E> ArrayDeque<E> newArrayDeque(Iterable<? extends E> elements) {
    if (elements instanceof Collection) {
      return new ArrayDeque<>((Collection<? extends E>) elements);
    }
    ArrayDeque<E> deque = new ArrayDeque<>();
    Iterables.addAll(deque, elements);
    return deque;
  }

        checkState(newMap instanceof MapMakerInternalMap);
        newMap.putAll(map);
        return newMap;
      }
    },
    MapMakerStrongKeysWeakValues {
      @Override
      public <K extends Comparable<K>, V> Map<K, V> create(Map<K, V> map) {
        ConcurrentMap<K, V> newMap = new MapMaker().weakValues().makeMap();
        checkState(newMap instanceof MapMakerInternalMap);
        newMap.putAll(map);

  }

  public static final class NullsBeforeB extends NullsBefore {
    public static final NullsBeforeB INSTANCE = new NullsBeforeB();

    private NullsBeforeB() {
      super("b");
    }
  }

  public static final class NullsBeforeTwo extends NullsBefore {
    public static final NullsBeforeTwo INSTANCE = new NullsBeforeTwo();

    private NullsBeforeTwo() {