}

  private boolean runCollectionTests = true;

  /**
   * Specify whether to skip the general collection tests. Call this method when testing a
   * collection that's both a queue and a list, to avoid running the common collection tests twice.
   * By default, collection tests do run.
   */
  @CanIgnoreReturnValue
  public QueueTestSuiteBuilder<E> skipCollectionTests() {
    runCollectionTests = false;

  }

  private void assertCollectionSize(Collection<?> collection, int size) {
    assertEquals(size, collection.size());
    if (size > 0) {
      assertFalse(collection.isEmpty());
    } else {
      assertTrue(collection.isEmpty());
    }
    assertEquals(size, Iterables.size(collection));
    assertEquals(size, Iterators.size(collection.iterator()));
  }

 */

package com.google.common.collect.testing;

import com.google.common.annotations.GwtCompatible;

/**
 * A type which will never be used as the element type of any collection in our tests, and so can be
 * used to test how a Collection behaves when given input of the wrong type.
 */
@GwtCompatible
public enum WrongType {
  VALUE

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.testing.features.CollectionSize;
import java.util.Collection;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * The subject-generator interface accepted by Collection testers, for testing a Collection at one
 * particular {@link CollectionSize}.
 *
 * <p>This interface should not be implemented outside this package; {@link

            boolean defaultsToEmpty);

    /**
     * Creates a composite function from a collection of functions.
     *
     * @param functions A collection of functions, each taking a String as input and returning a String.
     * @return A function that applies each function in the collection in order until a non-null result is found.
     *         If all functions return null, the composite function returns null.

  }

  @Override
  protected Collection<Method> suppressForConcurrentSkipListMap() {
    List<Method> methods = new ArrayList<>();
    methods.addAll(super.suppressForConcurrentSkipListMap());
    methods.add(getContainsEntryWithIncomparableKeyMethod());
    methods.add(getContainsEntryWithIncomparableValueMethod());
    return methods;
  }

  @Override
  protected Collection<Method> suppressForHashtable() {

  public void testEquals_shorterList() {
    Collection<E> fewerElements = getSampleElements(getNumElements() - 1);
    assertFalse(
        "Lists of different sizes should not be equal.",
        getList().equals(new ArrayList<E>(fewerElements)));
  }

  public void testEquals_longerList() {
    Collection<E> moreElements = getSampleElements(getNumElements() + 1);
    assertFalse(

  }

  private void assertCollectionSize(Collection<?> collection, int size) {
    assertEquals(size, collection.size());
    if (size > 0) {
      assertFalse(collection.isEmpty());
    } else {
      assertTrue(collection.isEmpty());
    }
    assertEquals(size, Iterables.size(collection));
    assertEquals(size, Iterators.size(collection.iterator()));
  }

    Helpers.assertEqualIgnoringOrder(getSampleElements(), asList(collection.stream().toArray()));
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testStreamToArrayKnownOrder() {
    assertEquals(getOrderedElements(), asList(collection.stream().toArray()));
  }

  public void testStreamCount() {
    assertEquals(getNumElements(), collection.stream().count());
  }

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.core.collection;

import java.io.Serializable;
import java.util.AbstractSet;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * {@link Set} that is case-insensitive.
 *
 * @author higa
 */