ListMultimap<String, Integer> unusedA =
        MultimapBuilder.hashKeys().arrayListValues().<String, Integer>build();
    SortedSetMultimap<String, Integer> unusedB =
        rawtypeToWildcard(MultimapBuilder.linkedHashKeys().treeSetValues())
            .<String, Integer>build();
    SetMultimap<String, Integer> unusedC =
        MultimapBuilder.treeKeys(String.CASE_INSENSITIVE_ORDER)
            .hashSetValues()

public class PredicatesTest extends TestCase {
  private static final Predicate<@Nullable Integer> TRUE = Predicates.alwaysTrue();
  private static final Predicate<@Nullable Integer> FALSE = Predicates.alwaysFalse();
  private static final Predicate<@Nullable Integer> NEVER_REACHED =
      new Predicate<@Nullable Integer>() {
        @Override
        public boolean apply(@Nullable Integer i) {

      }
    },
    RANDOM {
      @Override
      void arrange(List<Integer> list) {}
    };

    abstract void arrange(List<Integer> list);
  }

  private ImmutableList<Integer> input;

  @BeforeExperiment
  void setUp() {
    checkArgument(size > 0, "empty collection not supported");
    Set<Integer> set = new LinkedHashSet<>(size);

    Random random = new Random();
    while (set.size() < size) {

  public void testTransformEquals() {
    Map<String, Integer> underlying = ImmutableMap.of("a", 0, "b", 1, "c", 2);
    Map<String, Integer> expected = transformValues(underlying, Functions.<Integer>identity());

    assertMapsEqual(expected, expected);

    Map<String, Integer> equalToUnderlying = Maps.newTreeMap();
    equalToUnderlying.putAll(underlying);

@NullUnmarked
public final class SetsFilterHashSetTest extends AbstractFilteredSetTest<Set<Integer>> {
  @Override
  Set<Integer> createUnfiltered(Iterable<Integer> contents) {
    return newHashSet(contents);
  }

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

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

        // Generate multiple callable tasks
        final List<Callable<Integer>> tasks = new ArrayList<Callable<Integer>>();

    Iterable<Integer> result =
        Iterables.transform(
            input,
            new Function<String, Integer>() {
              @Override
              public Integer apply(String from) {
                return Integer.valueOf(from);
              }
            });

    List<Integer> actual = newArrayList(result);
    List<Integer> expected = asList(1, 2, 3);

    Collection<List<Integer>> permutationSet =
        Collections2.permutations(Collections.<Integer>emptyList());

    assertEquals(1, permutationSet.size());
    assertTrue(permutationSet.contains(Collections.<Integer>emptyList()));

    Iterator<List<Integer>> permutations = permutationSet.iterator();
    assertNextPermutation(Collections.<Integer>emptyList(), permutations);

     *
     * @return list of page numbers
     */
    public List<Integer> getPageNumberList() {
        return pageNumberList;
    }

    /**
     * Sets the list of page numbers for pagination navigation.
     *
     * @param pageNumberList list of page numbers
     */
    public void setPageNumberList(final List<Integer> pageNumberList) {
        this.pageNumberList = pageNumberList;
    }

      } else {
        return first.compareTo(second);
      }
    }
  }

  /** Decreasing integer values. A {@code null} comes before any non-null value. */
  private static final Comparator<@Nullable Integer> DECREASING_INT_COMPARATOR =
      Ordering.<Integer>natural().reverse().<Integer>nullsFirst();

  private SetMultimap<String, Integer> create() {
    return TreeMultimap.create(StringLength.COMPARATOR, DECREASING_INT_COMPARATOR);
  }