private final Element propertiesTable
    private final Element methodsTable
    private final Element propertiesSection
    private final Element methodsSection
    ClassDoc superClass
    List<ClassDoc> interfaces = []
    List<ClassDoc> subClasses = []
    List<Element> comment = []

### Validación { #validation }

* Validación para la mayoría (¿o todas?) de los **tipos de datos** de Python, incluyendo:
    * Objetos JSON (`dict`).
    * Array JSON (`list`) definiendo tipos de elementos.
    * Campos de cadena de caracteres (`str`), definiendo longitudes mínimas y máximas.
    * Números (`int`, `float`) con valores mínimos y máximos, etc.

* Validación para tipos más exóticos, como:
    * URL.

            Element element = document.createElement("NO-VALUE-FOR_FIELD");
            element.appendChild(document.createTextNode(targetClass.getClassName() + ":" + parts[1]));
            return element;
        }

        return createLiteralNode(value);
    }

    private Node createLiteralNode(String value) {
        Element element = document.createElement("literal");

    return new Ints();
  }

  @Override
  public Set<Integer> create(Object... elements) {
    Integer[] array = new Integer[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (Integer) e;
    }
    return create(array);
  }

  protected abstract Set<Integer> create(Integer[] elements);

  @Override
  public Integer[] createArray(int length) {
    return new Integer[length];

Args = -H:+AddAllCharsets --enable-http --enable-https --features=okhttp3.internal.graal.OkHttpFeature --report-unsupported-elements-at-runtime...

        multimap.putAll("foo", asList(7, 8));
        return multimap.get("foo").iterator();
      }

      @Override
      protected void verify(List<Integer> elements) {
        assertEquals(new HashSet<>(elements), multimap.get("foo"));
      }
    }.test();
  }

  @GwtIncompatible // unreasonably slow
  public void testEntriesIteration() {
    Set<Entry<String, Integer>> set =

	default:
		return "unknown"
	}
}

// AccElem holds information for calculating an average value
type AccElem struct {
	Total int64
	Size  int64
	N     int64
}

// Add a duration to a single element.
func (a *AccElem) add(dur time.Duration) {
	if dur < 0 {
		dur = 0
	}
	a.Total += int64(dur)
	a.N++
}

// Merge b into a.
func (a *AccElem) merge(b AccElem) {
	a.N += b.N
	a.Total += b.Total

  final transient E element;

  SingletonImmutableSet(E element) {
    this.element = Preconditions.checkNotNull(element);
  }

  @Override
  public int size() {
    return 1;
  }

  @Override
  public boolean contains(@Nullable Object target) {
    return element.equals(target);
  }

  @Override
  public UnmodifiableIterator<E> iterator() {

  }

  public static class Chars extends SampleElements<Character> {
    public Chars() {
      // elements aren't sorted, to better test SortedSet iteration ordering
      super('b', 'a', 'c', 'd', 'e');
    }
  }

  public static class Enums extends SampleElements<AnEnum> {
    public Enums() {
      // elements aren't sorted, to better test SortedSet iteration ordering
      super(AnEnum.B, AnEnum.A, AnEnum.C, AnEnum.D, AnEnum.E);

import java.util.Collection;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
import org.junit.Ignore;

/**
 * Base class for collection testers.
 *
 * @param <E> the element type of the collection to be tested.
 * @author Kevin Bourrillion
 */
@GwtCompatible
@Ignore("test runners must not instantiate and run this directly, only via suites we build")