assertNextPermutation(newArrayList(3, 2, 1), permutations);
    assertNextPermutation(newArrayList(2, 3, 1), permutations);
    assertNextPermutation(newArrayList(2, 1, 3), permutations);
    assertNoMorePermutations(permutations);
  }

  public void testPermutationSetThreeElementsOutOfOrder() {
    Iterator<List<Integer>> permutations =
        Collections2.permutations(newArrayList(3, 2, 1)).iterator();

### Changed
_Nothing has changed._

### Removed
_Nothing has changed._



# v1.32.1


## Downloads for v1.32.1



### Source Code

filename | sha512 hash
-------- | -----------

          .that(UnsignedInteger.fromIntBits(value).longValue())
          .isEqualTo(expected);
    }
  }

  public void testValueOfLong() {
    long min = 0;
    long max = (1L << 32) - 1;
    for (long value : TEST_LONGS) {
      boolean expectSuccess = value >= min && value <= max;
      try {
        assertThat(UnsignedInteger.valueOf(value).longValue()).isEqualTo(value);

    assertTrue(Objects.hashCode(1, 2, null) != Objects.hashCode(1, null, 2));
    assertTrue(Objects.hashCode(1, null, 2) != Objects.hashCode(1, 2));
    assertTrue(Objects.hashCode(1, 2, 3) != Objects.hashCode(3, 2, 1));
    assertTrue(Objects.hashCode(1, 2, 3) != Objects.hashCode(2, 3, 1));
  }

  @J2ktIncompatible
  @GwtIncompatible // NullPointerTester
  public void testNullPointers() {

        .addEqualityGroup(
            newHashSet(3, 2),
            union(singleton(3), singleton(2)),
            intersection(newHashSet(3, 2), newHashSet(3, 2, 1)),
            difference(newHashSet(3, 2, 1), newHashSet(1)),
            symmetricDifference(newHashSet(3, 1), newHashSet(2, 1)))
        .addEqualityGroup(
            newHashSet(1, 2, 3),

        // Clear execution order before test
        PriorityTrackingBooster.clearExecutionOrder();

        scoreUpdater.execute();

        // Boosters should be executed in priority order (3, 2, 1)
        List<Integer> executionOrder = PriorityTrackingBooster.getExecutionOrder();
        assertEquals(3, executionOrder.size());
        assertEquals(Integer.valueOf(3), executionOrder.get(0));

    multimap.put("foo", 3);
    multimap.put("bar", 1);
    multimap.putAll("foo", asList(-1, 2, 4));
    multimap.putAll("bar", asList(2, 3));
    multimap.put("foo", 1);
    assertEquals("{bar=[3, 2, 1], foo=[4, 3, 2, 1, -1]}", multimap.toString());
  }

  public void testGetComparator() {
    TreeMultimap<@Nullable String, @Nullable Integer> multimap = createPopulate();

    }
    return offset + size;
  }

  /**
   * Returns a view of this immutable list in reverse order. For example, {@code ImmutableList.of(1,
   * 2, 3).reverse()} is equivalent to {@code ImmutableList.of(3, 2, 1)}.
   *
   * @return a view of this immutable list in reverse order
   * @since 7.0
   */
  public ImmutableList<E> reverse() {
    return (size() <= 1) ? this : new ReverseImmutableList<E>(this);
  }

    assertToStringWorks("CharMatcher.anyOf(\"\\u0031\\u0032\")", CharMatcher.anyOf("12"));
    assertToStringWorks("CharMatcher.anyOf(\"\\u0031\\u0032\\u0033\")", CharMatcher.anyOf("321"));
    assertToStringWorks("CharMatcher.inRange('\\u0031', '\\u0033')", CharMatcher.inRange('1', '3'));
  }

  private static void assertToStringWorks(String expected, CharMatcher matcher) {

                int numThreads = ComponentUtil.getFessConfig().getRankFusionThreadsAsInteger();
                if (numThreads <= 0) {
                    numThreads = Runtime.getRuntime().availableProcessors() * 3 / 2 + 1;
                }
                executorService = Executors.newFixedThreadPool(numThreads);
            }
        }
    }