}

  @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();
  }

        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() {

    assertFalse(Assignability.of().isAssignable());
    assertTrue(new Assignability<Integer, Integer>() {}.isAssignable());
    assertTrue(new Assignability<Integer, Object>() {}.isAssignable());
    assertFalse(new Assignability<Integer, String>() {}.isAssignable());
    TypeTokenTest.<Number, Integer>assignabilityTestWithTypeVariables();
  }

                // Mock execution
            }
        };

        // Mock ComponentUtil
        ComponentUtil.setFessConfig(new TestFessConfig() {
            @Override
            public Integer getJobMaxCrawlerProcessesAsInteger() {
                return 5;
            }
        });

        ComponentUtil.register(new KeyMatchHelper() {
            @Override
            public void update() {

  private final boolean allowsSelfLoops;
  private final boolean allowsParallelEdges;
  private final ElementOrder<Integer> nodeOrder;
  private final ElementOrder<String> edgeOrder;

  public StandardMutableUndirectedNetworkTest(
      boolean allowsSelfLoops,
      boolean allowsParallelEdges,
      ElementOrder<Integer> nodeOrder,
      ElementOrder<String> edgeOrder) {
    this.allowsSelfLoops = allowsSelfLoops;

            false, "Integer", 0, 0, null, null, false, null, null, null, null, null, false);
    protected final ColumnInfo _columnTimeToLive = cci("timeToLive", "timeToLive", null, null, Integer.class, "timeToLive", null, false,
            false, false, "Integer", 0, 0, null, null, false, null, null, null, null, null, false);

@NullUnmarked
public final class SetsFilterNavigableSetTest extends AbstractFilteredNavigableSetTest {
  @Override
  NavigableSet<Integer> createUnfiltered(Iterable<Integer> contents) {
    return Sets.newTreeSet(contents);
  }

  @Override
  NavigableSet<Integer> filter(
      NavigableSet<Integer> elements, Predicate<? super Integer> predicate) {
    return Sets.filter(elements, predicate);
  }

    cache =
        CacheBuilder.newBuilder()
            .concurrencyLevel(segments)
            .maximumSize(maximumSize)
            .build(
                new CacheLoader<Integer, Integer>() {
                  @Override
                  public Integer load(Integer from) {
                    return (int) misses.incrementAndGet();
                  }
                });

    // To start, fill up the cache.

      Arrays.sort(dataset);
      return singleQuantileFromSorted(index, scale, dataset);
    }

    @Override
    Map<Integer, Double> multipleQuantiles(
        Collection<Integer> indexes, int scale, double[] dataset) {
      Arrays.sort(dataset);
      ImmutableMap.Builder<Integer, Double> builder = ImmutableMap.builder();
      for (int index : indexes) {

    public void testToObjectArray() throws Exception {
        final Object[] a = ArrayUtil.toObjectArray(new int[] { 1, 5, 2 });
        assertArrayEquals(new Integer[] { Integer.valueOf(1), Integer.valueOf(5), Integer.valueOf(2) }, a);
    }

    /**
     * @throws Exception
     */
    @Test(expected = IllegalArgumentException.class)
    public void testToObjectArray_NoArray() throws Exception {