*            The raw class. Must not be {@literal null}.
     */
    public ParameterizedClassDescImpl(final Class<?> rawClass) {
        assertArgumentNotNull("rawClass", rawClass);

        this.rawClass = rawClass;
    }

    /**
     * Constructs an instance.
     *
     * @param rawClass
     *            The raw class. Must not be {@literal null}.
     * @param arguments

 */

package com.google.common.hash;

import com.google.common.base.Supplier;
import com.google.errorprone.annotations.Immutable;

/**
 * Explicitly named subinterface of {@link Supplier} that can be marked {@literal @}{@link
 * Immutable}.
 */
// TODO(cpovirk): Should we just use ChecksumType directly instead of defining this type?
@Immutable

        default -> Boolean.TRUE;
        };
        default -> Boolean.TRUE;
        };
    }

    /**
     * Converts to {@literal boolean}.
     *
     * @param o
     *            The object to convert
     * @return The converted {@literal boolean}
     */
    public static boolean toPrimitiveBoolean(final Object o) {
        final Boolean b = toBoolean(o);
        if (b != null) {

    /**
     * Returns an {@link Iterable} that wraps an {@link Enumeration} for use in a for-each statement.
     *
     * @param <T> the element type
     * @param enumeration the enumeration (must not be {@literal null})
     * @return an {@link Iterable} wrapping the enumeration
     */
    public static <T> Iterable<T> iterable(final Enumeration<T> enumeration) {
        assertArgumentNotNull("enumeration", enumeration);

     */
    protected DocumentBuilderUtil() {
    }

    /**
     * Parses the XML.
     *
     * @param builder
     *            {@link DocumentBuilder}; must not be {@literal null}.
     * @param is
     *            Input stream; must not be {@literal null}.
     * @return {@link Document}
     */
    public static Document parse(final DocumentBuilder builder, final InputStream is) {
        assertArgumentNotNull("builder", builder);

    }

    private static final int BYTE_ARRAY_SIZE = 8 * 1024;

    /**
     * Tests if the object can be serialized.
     *
     * @param obj the object to be serialized (must not be {@literal null})
     * @return the deserialized object
     */
    public static Object serialize(final Object obj) {
        assertArgumentNotNull("obj", obj);

        final byte[] binary = fromObjectToBinary(obj);

    }

    /**
     * A method that wraps the exception handling of {@link ZipInputStream#getNextEntry()}.
     *
     * @param zis
     *            {@link ZipInputStream}. Must not be {@literal null}.
     * @return {@link ZipEntry}
     * @see ZipInputStream#getNextEntry()
     */
    public static ZipEntry getNextEntry(final ZipInputStream zis) {
        assertArgumentNotNull("zis", zis);

        try {

     * @return an {@link Iterable} wrapping a {@link ClassLoaderIterator}
     */
    public static Iterable<ClassLoader> iterable(final ClassLoader classLoader) {
        return () -> new ClassLoaderIterator(classLoader);
    }

    /**
     * Constructs an instance.
     *
     * @param classLoader the class loader (must not be {@literal null})
     */

 *    "www.squareup.com".
 *
 *  * **A set of hostnames.** These are in the certificate's subject alternative name (SAN)
 *    extension. A subject alternative name is either a literal hostname (`squareup.com`), a literal
 *    IP address (`74.122.190.80`), or a hostname pattern (`*.api.squareup.com`).
 *
 *  * **A validity interval.** A certificate should not be used before its validity interval starts
 *    or after it ends.

  }

  @SuppressWarnings("rawtypes") // class literals
  static final List<? extends Class<? extends AbstractTester>> TESTERS =
      asList(
          ConcurrentMapPutIfAbsentTester.class,
          ConcurrentMapRemoveTester.class,
          ConcurrentMapReplaceTester.class,
          ConcurrentMapReplaceEntryTester.class);

  @SuppressWarnings("rawtypes") // class literals
  @Override