.isEqualTo((byte) 255);
  }

  public void testMin_noArgs() {
    assertThrows(IllegalArgumentException.class, () -> UnsignedBytes.min());
  }

  public void testMin() {
    assertThat(UnsignedBytes.min(LEAST)).isEqualTo(LEAST);
    assertThat(UnsignedBytes.min(GREATEST)).isEqualTo(GREATEST);
    assertThat(UnsignedBytes.min((byte) 0, (byte) -128, (byte) -1, (byte) 127, (byte) 1))

    assertThat(LONG_MANY_VALUES_STATS_ITERATOR.max()).isEqualTo(LONG_MANY_VALUES_MAX);
    assertThat(LONG_MANY_VALUES_STATS_SNAPSHOT.max()).isEqualTo(LONG_MANY_VALUES_MAX);
  }

  public void testMin() {
    assertThrows(IllegalStateException.class, () -> EMPTY_STATS_VARARGS.min());
    assertThrows(IllegalStateException.class, () -> EMPTY_STATS_ITERABLE.min());
    assertThat(ONE_VALUE_STATS.min()).isEqualTo(ONE_VALUE);

        .isEqualTo((char) 9);
  }

  public void testMin_noArgs() {
    try {
      Chars.min();
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMin() {
    assertThat(Chars.min(LEAST)).isEqualTo(LEAST);
    assertThat(Chars.min(GREATEST)).isEqualTo(GREATEST);
    assertThat(Chars.min((char) 8, (char) 6, (char) 7, (char) 5, (char) 3, (char) 0, (char) 9))

    assertThat(longManyValuesAccumulatorByAddAllIterator.max()).isEqualTo(LONG_MANY_VALUES_MAX);
    assertThat(longManyValuesAccumulatorByAddAllVarargs.max()).isEqualTo(LONG_MANY_VALUES_MAX);
  }

  public void testMin() {
    assertThrows(IllegalStateException.class, () -> emptyAccumulator.min());
    assertThrows(IllegalStateException.class, () -> emptyAccumulatorByAddAllEmptyIterable.min());

  }

  @GwtIncompatible
  public void testMin_noArgs() {
    try {
      Doubles.min();
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMin() {
    assertThat(Doubles.min(LEAST)).isEqualTo(LEAST);
    assertThat(Doubles.min(GREATEST)).isEqualTo(GREATEST);
    assertThat(
            Doubles.min(

  }

  @GwtIncompatible
  public void testMin_noArgs() {
    try {
      Ints.min();
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMin() {
    assertThat(Ints.min(LEAST)).isEqualTo(LEAST);
    assertThat(Ints.min(GREATEST)).isEqualTo(GREATEST);
    assertThat(Ints.min((int) 8, (int) 6, (int) 7, (int) 5, (int) 3, (int) 0, (int) 9))

  }

  @GwtIncompatible
  public void testMin_noArgs() {
    try {
      Shorts.min();
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMin() {
    assertThat(Shorts.min(LEAST)).isEqualTo(LEAST);
    assertThat(Shorts.min(GREATEST)).isEqualTo(GREATEST);
    assertThat(

  }

  @GwtIncompatible
  public void testMin_noArgs() {
    try {
      Shorts.min();
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMin() {
    assertThat(Shorts.min(LEAST)).isEqualTo(LEAST);
    assertThat(Shorts.min(GREATEST)).isEqualTo(GREATEST);
    assertThat(

        .isEqualTo((long) 9);
  }

  public void testMin_noArgs() {
    try {
      Longs.min();
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMin() {
    assertThat(Longs.min(MIN_VALUE)).isEqualTo(MIN_VALUE);
    assertThat(Longs.min(MAX_VALUE)).isEqualTo(MAX_VALUE);
    assertThat(Longs.min((long) 8, (long) 6, (long) 7, (long) 5, (long) 3, (long) 0, (long) 9))

  }

  @GwtIncompatible
  public void testMin_noArgs() {
    try {
      Floats.min();
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMin() {
    assertThat(Floats.min(LEAST)).isEqualTo(LEAST);
    assertThat(Floats.min(GREATEST)).isEqualTo(GREATEST);
    assertThat(