new float[] {
        LEAST,
        -Float.MAX_VALUE,
        -1f,
        -0f,
        0f,
        1f,
        Float.MAX_VALUE,
        GREATEST,
        Float.MIN_NORMAL,
        -Float.MIN_NORMAL,
        Float.MIN_VALUE,
        -Float.MIN_VALUE,
        Integer.MIN_VALUE,
        Integer.MAX_VALUE,
        Long.MIN_VALUE,
        Long.MAX_VALUE
      };

            opLambda.callback(builder);
        }
    }

    public void setCreatedTime_Max() {
        setCreatedTime_Max(null);
    }

    public void setCreatedTime_Max(ConditionOptionCall<MaxAggregationBuilder> opLambda) {
        setCreatedTime_Max("createdTime", opLambda);
    }

    public void setCreatedTime_Max(String name, ConditionOptionCall<MaxAggregationBuilder> opLambda) {

    BigInteger maxDoubleAsBI = DoubleMath.roundToBigInteger(Double.MAX_VALUE, UNNECESSARY);
    new RoundToDoubleTester(maxDoubleAsBI).setExpectation(Double.MAX_VALUE, values()).test();
  }

  @J2ktIncompatible
  @GwtIncompatible
  public void testRoundToDouble_maxDoublePlusOne() {
    BigInteger maxDoubleAsBI =
        DoubleMath.roundToBigInteger(Double.MAX_VALUE, UNNECESSARY).add(BigInteger.ONE);

    BigInteger maxDoubleAsBI = DoubleMath.roundToBigInteger(Double.MAX_VALUE, UNNECESSARY);
    new RoundToDoubleTester(maxDoubleAsBI).setExpectation(Double.MAX_VALUE, values()).test();
  }

  @J2ktIncompatible
  @GwtIncompatible
  public void testRoundToDouble_maxDoublePlusOne() {
    BigInteger maxDoubleAsBI =
        DoubleMath.roundToBigInteger(Double.MAX_VALUE, UNNECESSARY).add(BigInteger.ONE);

                        }
                    }
                }

                int max = Math.min( dc_list.length, LOOKUP_RESP_LIMIT );
                for (int j = 0; j < max; j++) {
                    int i = dc_list_counter++ % max;
                    if (dc_list[i] != null) {
                        try {
                            return interrogate( dc_list[i] );

          + (-2.2 - MANY_VALUES_MEAN) * (-2.2 - MANY_VALUES_MEAN);
  static final double MANY_VALUES_MAX = 555.555;
  static final double MANY_VALUES_MIN = -44.44;

  // Doubles which will overflow if summed:
  static final double[] LARGE_VALUES = {Double.MAX_VALUE, Double.MAX_VALUE / 2.0};
  static final double LARGE_VALUES_MEAN = 0.75 * Double.MAX_VALUE;

  static final ImmutableList<Double> OTHER_MANY_VALUES =

import javax.validation.constraints.Size;

import org.lastaflute.web.validation.Required;

public class DeleteForm {

    @Required
    @Size(max = 100)
    public String name;

    @Size(max = 100)
    public String version;

import javax.validation.constraints.Size;

import org.lastaflute.web.validation.Required;

public class InstallBody {
    @Required
    @Size(max = 100)
    public String name;

    @Required
    @Size(max = 100)
    public String version;

  }

  public void testMax_noArgs() {
    try {
      UnsignedLongs.max();
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMax() {
    assertThat(UnsignedLongs.max(LEAST)).isEqualTo(LEAST);
    assertThat(UnsignedLongs.max(GREATEST)).isEqualTo(GREATEST);
    assertThat(
            UnsignedLongs.max(

public abstract class IntsMethodsForWeb {

  @JsMethod(name = "Math.min", namespace = JsPackage.GLOBAL)
  public static native int min(int... array);

  @JsMethod(name = "Math.max", namespace = JsPackage.GLOBAL)
  public static native int max(int... array);