problem = new DefaultProblem(null, null, null, Integer.MAX_VALUE, -1, null);
        assertEquals(Integer.MAX_VALUE, problem.getLineNumber());

        // this case is not specified, might also return -1
        problem = new DefaultProblem(null, null, null, Integer.MIN_VALUE, -1, null);
        assertEquals(Integer.MIN_VALUE, problem.getLineNumber());
    }

    @Test
    void testGetColumnNumber() {

    }

    @Override
    public int add(E element, int occurrences) {
      checkArgument(occurrences >= 0);
      Integer frequency = backingMap.getOrDefault(element, 0);
      if (occurrences == 0) {
        return frequency;
      }
      checkArgument(occurrences <= Integer.MAX_VALUE - frequency);
      backingMap.put(element, frequency + occurrences);
      return frequency;
    }

    @Override

   * returns {@code type} itself. Idempotent.
   *
   * <pre>
   *     wrap(int.class) == Integer.class
   *     wrap(Integer.class) == Integer.class
   *     wrap(String.class) == String.class
   * </pre>
   */
  public static <T> Class<T> wrap(Class<T> type) {
    checkNotNull(type);

    // cast is safe: long.class and Long.class are both of type Class<Long>

  }

  @Override
  final void addNode(Integer n) {
    graphBuilder.addNode(n);
    graph = graphBuilder.build();
  }

  @Override
  final void putEdge(Integer n1, Integer n2) {
    graphBuilder.putEdge(n1, n2);
    graph = graphBuilder.build();
  }

  }

  @Override
  final void addNode(Integer n) {
    graphBuilder.addNode(n);
    graph = graphBuilder.build();
  }

  @Override
  final void putEdge(Integer n1, Integer n2) {
    graphBuilder.putEdge(n1, n2);
    graph = graphBuilder.build();
  }

    assertEquals(
        Integer.MAX_VALUE, ImmutableCollection.Builder.expandedCapacity(0, Integer.MAX_VALUE));
    assertEquals(
        Integer.MAX_VALUE, ImmutableCollection.Builder.expandedCapacity(1, Integer.MAX_VALUE));
    assertEquals(
        Integer.MAX_VALUE,
        ImmutableCollection.Builder.expandedCapacity(Integer.MAX_VALUE - 1, Integer.MAX_VALUE));

                            "id": {
                                "anyOf": [{"type": "integer"}, {"type": "null"}],
                                "title": "Id",
                            },
                            "name": {"type": "string", "title": "Name"},
                            "age": {
                                "anyOf": [{"type": "integer"}, {"type": "null"}],
                                "title": "Age",

    @CanIgnoreReturnValue // Sure, why not?
    @Override
    public Integer load(Integer key) {
      countLoad.incrementAndGet();
      return key;
    }

    @GwtIncompatible // reload
    @Override
    public ListenableFuture<Integer> reload(Integer key, Integer oldValue) {
      countReload.incrementAndGet();
      return immediateFuture(oldValue + 1);
    }

        new TypeResolver()
            .where(
                new TypeCapture<Map<Integer, T>>() {}.capture(),
                new TypeCapture<Map<? extends Number, ? extends Number>>() {}.capture())
            .resolveType(subtype);
  }

  interface TypedKeyMap<T> extends Map<Integer, T> {}

  interface TypedListKeyMap<T> extends Map<List<Integer>, T> {}

  private static <T> Type aTypeVariable() {

    super(true, true, true, true, true);
  }

  @Override
  protected SortedMap<String, Integer> makeEmptyMap() {
    return new SimpleForwardingSortedMap<>(
        new TreeMap<String, Integer>(Ordering.<String>natural().nullsFirst()));
  }

  @Override
  protected SortedMap<String, Integer> makePopulatedMap() {
    SortedMap<String, Integer> sortedMap = makeEmptyMap();
    sortedMap.put("one", 1);
    sortedMap.put("two", 2);