}

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddTooMany() {
    getMultiset().add(e3(), Integer.MAX_VALUE);
    assertThrows(IllegalArgumentException.class, () -> getMultiset().add(e3()));
    assertEquals(Integer.MAX_VALUE, getMultiset().count(e3()));
    assertEquals(Integer.MAX_VALUE, getMultiset().size());
  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddAll_emptySet() {

  protected volatile boolean throwException = false;

  protected final ListenableFutureTask<Integer> task =
      ListenableFutureTask.create(
          new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
              runLatch.countDown();
              taskLatch.await();
              if (throwException) {

    private final Integer buildNumber;

    RemoteSnapshotMetadata(Artifact artifact, Date timestamp, Integer buildNumber) {
        super(createRepositoryMetadata(artifact), null, timestamp);
        this.buildNumber = buildNumber;
    }

    private RemoteSnapshotMetadata(Metadata metadata, Path path, Date timestamp, Integer buildNumber) {
        super(metadata, path, timestamp);

   *
   * <p>For undirected graphs, this is equal to {@code incidentEdges(node).size()} + (number of
   * self-loops incident to {@code node}).
   *
   * <p>If the count is greater than {@code Integer.MAX_VALUE}, returns {@code Integer.MAX_VALUE}.
   *
   * @throws IllegalArgumentException if {@code node} is not an element of this graph
   */
  @Override
  int degree(N node);

  /**

   *
   * <p>For undirected graphs, this is equal to {@code incidentEdges(node).size()} + (number of
   * self-loops incident to {@code node}).
   *
   * <p>If the count is greater than {@code Integer.MAX_VALUE}, returns {@code Integer.MAX_VALUE}.
   *
   * @throws IllegalArgumentException if {@code node} is not an element of this graph
   */
  @Override
  int degree(N node);

  /**

                    "properties": {
                        "items": {
                            "title": "Items",
                            "type": "object",
                            "additionalProperties": {"type": "integer"},
                        }
                    },
                },
                "ValidationError": {
                    "title": "ValidationError",
                    "required": ["loc", "msg", "type"],

    List<Integer> list = emptyList();
    Iterator<Integer> iterator = peekingIterator(new ThrowsAtEndIterator<Integer>(list));
    assertNextThrows(iterator);

    /* Checks the case where a later element throws an exception. */

    list = Lists.newArrayList(1, 2);
    iterator = peekingIterator(new ThrowsAtEndIterator<Integer>(list));
    assertTrue(iterator.hasNext());

  public ArrayTableColumnMapTest() {
    super(true, false, false, false);
  }

  @Override
  Table<Integer, String, Character> makeTable() {
    return ArrayTable.create(asList(1, 2, 3), asList("foo", "bar", "dog"));
  }

  @Override
  protected Map<String, Map<Integer, Character>> makeEmptyMap() {
    throw new UnsupportedOperationException();
  }

  public ArrayTableRowMapTest() {
    super(true, false, false, false);
  }

  @Override
  Table<String, Integer, Character> makeTable() {
    return ArrayTable.create(asList("foo", "bar", "dog"), asList(1, 2, 3));
  }

  @Override
  protected Map<String, Map<Integer, Character>> makeEmptyMap() {
    throw new UnsupportedOperationException();
  }

                "item_id"
            ],
            "msg": "value is not a valid integer",
            "type": "type_error.integer"
        }
    ]
}
```

you will get a text version, with:

```
Validation errors:
Field: ('path', 'item_id'), Error: Input should be a valid integer, unable to parse string as an integer
```