}
      }
    }
    return super.containsAll(collection);
  }

  @Override
  public Iterator<E> iterator() {
    return asList(contents).iterator();
  }

  @Override
  public @Nullable Object[] toArray() {
    @Nullable Object[] result = new @Nullable Object[contents.length];
    arraycopy(contents, 0, result, 0, contents.length);
    return result;
  }

  /*

  private static MultiInputStream tenMillionEmptySources() throws IOException {
    return new MultiInputStream(Collections.nCopies(10_000_000, ByteSource.empty()).iterator());
  }

  private static ByteSource newByteSource(int start, int size) {
    return new ByteSource() {
      @Override
      public InputStream openStream() {
        return new ByteArrayInputStream(newPreFilledByteArray(start, size));
      }
    };
  }

    }
  }

  /** Previous version of BigIntegerMath.factorial, kept for timing purposes. */
  private static BigInteger oldSlowFactorial(int n) {
    if (n <= 20) {
      return BigInteger.valueOf(LongMath.factorial(n));
    } else {
      int k = 20;
      return BigInteger.valueOf(LongMath.factorial(k)).multiply(oldSlowFactorial(k, n));
    }
  }

  /** Returns the product of {@code n1} exclusive through {@code n2} inclusive. */

            return false;
          }

          @Override
          public boolean isDone() {
            return true;
          }

          @Override
          public boolean isCancelled() {
            return true; // BAD!!
          }

          @Override
          public String get() {
            return "foo"; // BAD!!
          }

        public String getPath() {
            return path;
        }

        @Override
        public void setPath(String path) {
            this.path = path;
        }

        @Override
        public String getServer() {
            return server;
        }

        @Override
        public String getDomain() {
            return domain;
        }

        @Override

                try {
                  return method.invoke(target, args);
                } catch (InvocationTargetException e) {
                  throw throwCause(e, /* combineStackTraces= */ false);
                }
              };
          return callWithTimeout(
              callable, timeoutDuration, timeoutUnit, interruptibleMethods.contains(method));
        };
    return newProxy(interfaceType, handler);
  }

    return comparator.compare(a, b);
  }

  @Override
  public boolean equals(@Nullable Object object) {
    if (object == this) {
      return true;
    }
    if (object instanceof ComparatorOrdering) {
      ComparatorOrdering<?> that = (ComparatorOrdering<?>) object;
      return this.comparator.equals(that.comparator);
    }
    return false;
  }

  @Override

     * nullness checker (resulting from https://github.com/jspecify/checker-framework/issues/8).
     */
    if (result == null) {
      return null;
    } else {
      return (V) result;
    }
  }

  @Override
  ImmutableSet<Entry<K, V>> createEntrySet() {
    return new RegularImmutableMap.EntrySet<K, V>(this, alternatingKeysAndValues, keyOffset, size);
  }

  @Override
  ImmutableSet<K> createKeySet() {

     * Checks if the log level is DEBUG.
     *
     * @return true if DEBUG, false otherwise
     */
    public boolean isDebugEnabled() {
        return DEBUG.equals(logLevel);
    }

    /**
     * Checks if the log level is INFO.
     *
     * @return true if INFO, false otherwise
     */
    public boolean isInfoEnabled() {
        return INFO.equals(logLevel);
    }

    /**

    @Override
    boolean wasEvicted() {
      return false;
    }
  },

  /**
   * The entry was removed automatically because its key or value was garbage-collected. This can
   * occur when using {@link CacheBuilder#weakKeys}, {@link CacheBuilder#weakValues}, or {@link
   * CacheBuilder#softValues}.
   */
  COLLECTED {
    @Override
    boolean wasEvicted() {
      return true;
    }
  },

  /**