/**
 * Tester for {@code Collector} implementations.
 *
 * <p>Example usage:
 *
 * <pre>
 * CollectorTester.of(Collectors.summingInt(Integer::parseInt))
 *     .expectCollects(3, "1", "2")
 *     .expectCollects(10, "1", "4", "3", "2")
 *     .expectCollects(5, "-3", "0", "8");
 * </pre>
 *
 * @author Louis Wasserman
 * @since 21.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public final class CollectorTester<

    final int value;

    IntegerDiv10(int value) {
      this.value = value;
    }

    @Override
    public int compareTo(IntegerDiv10 o) {
      return value / 10 - o.value / 10;
    }

    @Override
    public String toString() {
      return Integer.toString(value);
    }
  }

  public void testCopyOfDuplicateInconsistentWithEquals() {

    return new FutureTask<>(
        new Callable<Boolean>() {
          @Override
          public Boolean call() throws Exception {
            assertEquals(RESULT, getUninterruptibly(future, 10, MINUTES));
            return Thread.interrupted();
          }
        });
  }

  private static final String RESULT = "result";

      ByteSourceFactory slicedOffsetPastEnd =
          SourceSinkFactories.asSlicedByteSourceFactory(
              factory, expected.length + 2, expected.length + 10);
      suite.addTest(
          suiteForBytes(slicedOffsetPastEnd, bytes, name + ".slice[size + 2, long]", desc, false));
    }

    return suite;
  }

  private ByteSource source;

  }

  /**
   * On a successful concurrent computation, only one thread does the work, but all the threads get
   * the same result.
   */
  private static void testConcurrentLoadingDefault(CacheBuilder<Object, Object> builder)
      throws InterruptedException {

    int count = 10;
    final AtomicInteger callCount = new AtomicInteger();

    assertFalse(in.closed());
    sink.writeFrom(in);
    assertFalse(in.closed());
  }

  public void testClosesOnErrors_copyingFromByteSourceThatThrows() {
    for (TestOption option : EnumSet.of(OPEN_THROWS, READ_THROWS, CLOSE_THROWS)) {
      TestByteSource failSource = new TestByteSource(new byte[10], option);
      TestByteSink okSink = new TestByteSink();

    assertEquals(-13.75, DoubleMath.mean(11, -22, 44, -88), 1.0e-10);
    assertEquals(11.0, DoubleMath.mean(11), 1.0e-10);
  }

  @GwtIncompatible // DoubleMath.mean
  public void testMean_longVarargs() {
    assertEquals(-13.75, DoubleMath.mean(11L, -22L, 44L, -88L), 1.0e-10);
    assertEquals(11.0, DoubleMath.mean(11L), 1.0e-10);
  }

  @GwtIncompatible // DoubleMath.mean

    final int value;

    IntegerDiv10(int value) {
      this.value = value;
    }

    @Override
    public int compareTo(IntegerDiv10 o) {
      return value / 10 - o.value / 10;
    }

    @Override
    public String toString() {
      return Integer.toString(value);
    }
  }

  public void testCopyOfDuplicateInconsistentWithEquals() {

  volatile Scheduler configuration = newFixedDelaySchedule(0, 10, MILLISECONDS);
  volatile @Nullable ScheduledFuture<?> future = null;

  volatile boolean atFixedRateCalled = false;
  volatile boolean withFixedDelayCalled = false;
  volatile boolean scheduleCalled = false;

  final ScheduledExecutorService executor =
      new ScheduledThreadPoolExecutor(10) {
        @Override

        ImmutableSet.of(
            Range.<Integer>all(),
            Range.<Integer>closedOpen(3, 5),
            Range.singleton(1),
            Range.lessThan(2),
            Range.greaterThan(10),
            Range.atMost(4),
            Range.atLeast(3),
            Range.closed(4, 6),
            Range.closedOpen(1, 3),
            Range.openClosed(5, 7),
            Range.open(3, 4));
    subsets: