import junit.framework.TestSuite;
import org.jspecify.annotations.NullUnmarked;

/**
 * Test suite covering {@link Ints#asList(int[])}.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
@SuppressWarnings("cast") // redundant casts are intentional and harmless
@NullUnmarked
@AndroidIncompatible // test-suite builders
public class IntArrayAsListTest extends TestCase {

  private static List<Integer> asList(Integer[] values) {

        if (graph.isEmptyEdges()) {
            return null; // no edges - nothing to worry about
        }

        final TreeSet<MetadataGraphVertex> vertices = graph.getVertices();

        try {
            // edge case - single vertex graph
            if (vertices.size() == 1) {
                return new MetadataGraph(entry);
            }

            final ArtifactScopeEnum requestedScope = ArtifactScopeEnum.checkScope(scope);

            if (type == null) {
                throw new NullPointerException("type");
            }
            if (type.isInstance(this)) {
                return type.cast(this);
            }
            return null;
        }

        @Override
        public String getUserDomain() {
            return this.domain;
        }

        @Override

 * <b>indiscriminately</b> to the methods of the delegate. For example, overriding {@link
 * #add(Object, int)} alone <b>will not</b> change the behavior of {@link #add(Object)}, which can
 * lead to unexpected behavior. In this case, you should override {@code add(Object)} as well,
 * either providing your own implementation, or delegating to the provided {@code standardAdd}
 * method.
 *

     * simple approach would be for each caller CAS it from null to a Set populated with its
     * exception. But there's another race: If the first thread fails with an exception and a second
     * thread immediately fails with the same exception:
     *
     * Thread1: calls setException(), which returns true, context switch before it can CAS
     * seenExceptionsField to its exception
     *

    `@Deprecated` APIs will remain (again, unless they are `@Beta`). We have no
    plans to start removing things again, but officially, we're leaving our
    options open in case of surprises (like, say, a serious security problem).

3.  Guava has one dependency that is needed for linkage at runtime:
    `com.google.guava:failureaccess:1.0.3`. It also has

   * threads can have different class loaders, for example app servers, the context class loader
   * will typically have been set to an appropriate loader for the current thread.
   *
   * <p>In the unusual case where the context class loader is null, the class loader that loaded
   * this class ({@code Resources}) will be used instead.
   *
   * @throws IllegalArgumentException if the resource is not found
   */

        switch (form.crudMode) {
        case CrudMode.CREATE:
            return OptionalEntity.of(new FileConfig()).map(entity -> {
                entity.setCreatedBy(username);
                entity.setCreatedTime(currentTime);
                return entity;
            });
        case CrudMode.EDIT:
            if (form instanceof EditForm) {

    private static OptionalEntity<ProtwordsItem> getEntity(final CreateForm form) {
        switch (form.crudMode) {
        case CrudMode.CREATE:
            final ProtwordsItem entity = new ProtwordsItem(0, StringUtil.EMPTY);
            return OptionalEntity.of(entity);
        case CrudMode.EDIT:
            if (form instanceof EditForm) {

  }

  private void updateInverseMap(
      @ParametricNullness K key,
      boolean containedKey,
      @Nullable V oldValue,
      @ParametricNullness V newValue) {
    if (containedKey) {
      // The cast is safe because of the containedKey check.
      removeFromInverseMap(uncheckedCastNullableTToT(oldValue));
    }
    inverse.delegate.put(newValue, key);
  }

  @CanIgnoreReturnValue
  @Override