return 30;
        }

        @Override
        public Integer getSuggestUpdateRequestIntervalAsInteger() {
            return 1000;
        }

        @Override
        public Integer getSuggestUpdateDocPerRequestAsInteger() {
            return 100;
        }

        @Override
        public Integer getSuggestSourceReaderScrollSizeAsInteger() {
            return 1000;
        }

    // to replace a bunch of one-off binary searches
    private static final Map<Integer, String> errorCodeMessages;
    private static final Map<Integer, String> winErrorCodeMessages;
    private static final Map<Integer, Integer> dosErrorCodeStatuses;

    static {
        final Map<Integer, String> errorCodeMessagesTmp = new HashMap<>();
        for (int i = 0; i < NT_STATUS_CODES.length; i++) {

        final Callable<Integer> testCallable = new Callable<Integer>() {
            public Integer call() throws Exception {
                CrawlingParameterUtil.setUrlQueue(q);
                controller.delayBeforeProcessing();
                return 0;
            }
        };

        // Callableタスクを複数生成
        final List<Callable<Integer>> tasks = new ArrayList<Callable<Integer>>();

  }

  public void testWrap() {
    assertThat(Primitives.wrap(int.class)).isSameInstanceAs(Integer.class);
    assertThat(Primitives.wrap(Integer.class)).isSameInstanceAs(Integer.class);
    assertThat(Primitives.wrap(String.class)).isSameInstanceAs(String.class);
  }

  public void testUnwrap() {
    assertThat(Primitives.unwrap(Integer.class)).isSameInstanceAs(int.class);

            }
        }

        // Assert: consumer called exactly for the 3 known codes, with the right arguments
        ArgumentCaptor<Integer> dosCaptor = ArgumentCaptor.forClass(Integer.class);
        ArgumentCaptor<Integer> ntCaptor = ArgumentCaptor.forClass(Integer.class);
        verify(consumer, times(3)).accept(dosCaptor.capture(), ntCaptor.capture());

    Set<Integer> set1 = newHashSet(1, 2);
    Set<Integer> set2 = newHashSet(2, 3);
    Set<Integer> difference = difference(set1, set2);
    assertThat(difference).containsExactly(1);
    set1.add(0);
    assertThat(difference).containsExactly(0, 1);
    set2.remove(2);
    assertThat(difference).containsExactly(0, 1, 2);
  }

  public void testSymmetricDifference_isView() {
    Set<Integer> set1 = newHashSet(1, 2);

    @Required
    @Min(value = 1)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer numOfThread;

    /**
     * The interval time between requests in milliseconds.
     */
    @Required
    @Min(value = 0)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer intervalTime;

    /**
     * The boost value for documents from this web configuration.
     */

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

  @Override
  Table<Integer, String, Character> makeTable() {
    Table<Integer, String, String> original = HashBasedTable.create();
    return transformValues(original, FIRST_CHARACTER);
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    Table<Integer, String, String> table = HashBasedTable.create();
    table.put(1, "foo", "apple");

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

  @Override
  Table<String, Integer, Character> makeTable() {
    Table<String, Integer, String> original = HashBasedTable.create();
    return transformValues(original, TableCollectionTest.FIRST_CHARACTER);
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {
    Table<String, Integer, String> table = HashBasedTable.create();
    table.put("foo", 1, "apple");

  }

  @Override
  Table<String, Character, Integer> makeTable() {
    RowSortedTable<String, Character, Integer> table = TreeBasedTable.create();
    return unmodifiableRowSortedTable(table);
  }

  @Override
  protected Map<String, Integer> makePopulatedMap() {
    RowSortedTable<String, Character, Integer> table = TreeBasedTable.create();
    table.put("one", 'a', 1);
    table.put("two", 'a', 2);