new float[] {2.0f, 3.0f, 2.0f, 3.0f, 4.0f, 2.0f, 3.0f},
                new float[] {2.0f, 3.0f, 4.0f}))
        .isEqualTo(2);
    assertThat(
            Floats.indexOf(
                new float[] {2.0f, 2.0f, 3.0f, 4.0f, 2.0f, 3.0f, 4.0f},
                new float[] {2.0f, 3.0f, 4.0f}))
        .isEqualTo(1);
    assertThat(Floats.indexOf(new float[] {4.0f, 3.0f, 2.0f}, new float[] {2.0f, 3.0f, 4.0f}))
        .isEqualTo(-1);

                new float[] {2.0f, 3.0f, 2.0f, 3.0f, 4.0f, 2.0f, 3.0f},
                new float[] {2.0f, 3.0f, 4.0f}))
        .isEqualTo(2);
    assertThat(
            Floats.indexOf(
                new float[] {2.0f, 2.0f, 3.0f, 4.0f, 2.0f, 3.0f, 4.0f},
                new float[] {2.0f, 3.0f, 4.0f}))
        .isEqualTo(1);
    assertThat(Floats.indexOf(new float[] {4.0f, 3.0f, 2.0f}, new float[] {2.0f, 3.0f, 4.0f}))
        .isEqualTo(-1);

 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible
public final class Defaults {
  private Defaults() {}

  private static final Double DOUBLE_DEFAULT = 0d;
  private static final Float FLOAT_DEFAULT = 0f;

  /**
   * Returns the default value of {@code type} as defined by JLS --- {@code 0} for numbers, {@code
   * false} for {@code boolean} and {@code '\0'} for {@code char}. For non-primitive types and

 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible
public final class Defaults {
  private Defaults() {}

  private static final Double DOUBLE_DEFAULT = 0d;
  private static final Float FLOAT_DEFAULT = 0f;

  /**
   * Returns the default value of {@code type} as defined by JLS --- {@code 0} for numbers, {@code
   * false} for {@code boolean} and {@code '\0'} for {@code char}. For non-primitive types and

        () -> MathPreconditions.checkNonNegative("int", BigInteger.ONE.negate()));
  }

  public void testCheckNonNegative_zeroFloat() {
    MathPreconditions.checkNonNegative("float", 0f);
  }

  public void testCheckNonNegative_maxFloat() {
    MathPreconditions.checkNonNegative("float", Float.MAX_VALUE);
  }

  public void testCheckNonNegative_minFloat() {

        () -> MathPreconditions.checkNonNegative("int", BigInteger.ONE.negate()));
  }

  public void testCheckNonNegative_zeroFloat() {
    MathPreconditions.checkNonNegative("float", 0f);
  }

  public void testCheckNonNegative_maxFloat() {
    MathPreconditions.checkNonNegative("float", Float.MAX_VALUE);
  }

  public void testCheckNonNegative_minFloat() {

00000e0 c4 00 00 00 00 ff ff 00 00 00 ff ff 00 34 00 cb
00000f0 ff 42 88 21 c4 00 00 00 00 ff ff 00 00 00 ff ff
0000100 00 34 00 cb ff 42 e8 21 5e 0f 00 00 00 ff ff 0a
0000110 f0 66 64 12 61 c0 15 dc e8 a0 48 bf 48 af 2a b3
0000120 20 c0 9b 95 0d c4 67 04 42 53 06 06 06 40 00 06
0000130 00 f9 ff 6d 01 00 00 00 00 42 e8 21 5e 0f 00 00
0000140 00 ff ff 0a f0 66 64 12 61 c0 15 dc e8 a0 48 bf
0000150 48 af 2a b3 20 c0 9b 95 0d c4 67 04 42 53 06 06

  }

  public void testHashFloatIsStable() {
    // Just a spot check.  Better than nothing.
    Hasher hasher = HASH_FN.newHasher();
    hasher.putFloat(0x01000101f).putFloat(0f);
    assertEquals(0x49f9d18ee8ae1b28L, hasher.hash().asLong());

    hasher = HASH_FN.newHasher();
    hasher.putDouble(0x0000000001000101d);
    assertEquals(0x388ee898bad75cbfL, hasher.hash().asLong());
  }

        QueryBuilder builder = queryProcessor.execute(context, prefixQuery, 10.0f);

        assertNotNull(builder);
        assertTrue(builder instanceof MatchPhrasePrefixQueryBuilder);

        // Query was processed with high boost
        MatchPhrasePrefixQueryBuilder mpqb = (MatchPhrasePrefixQueryBuilder) builder;
        assertEquals(10.0f, mpqb.boost());
    }

    @Test

        QueryContext context = new QueryContext("test", false);
        QueryBuilder result = queryProcessor.execute(context, boostQuery, 1.0f);

        assertNotNull(result);
        assertTrue(result instanceof MatchAllQueryBuilder);
        MatchAllQueryBuilder matchAllQueryBuilder = (MatchAllQueryBuilder) result;
        assertEquals(3.0f, matchAllQueryBuilder.boost());
    }