array[i] = counter.getAndIncrement();
        }
        builder.addAll(ImmutableIntArray.copyOf(array));
      }
    },
    ADD_LARGER_ARRAY {
      @Override
      void doIt(ImmutableIntArray.Builder builder, AtomicInteger counter) {
        int[] array = new int[RANDOM.nextInt(200) + 200];
        for (int i = 0; i < array.length; i++) {
          array[i] = counter.getAndIncrement();
        }

| header_1        | msgp bin array              | Header of version 1
| metadata_1      | msgp bin array              | Metadata of version 1
| ...header_n     | msgp bin array              | Header of last version
| ...metadata_n   | msgp bin array              | Metadata of last version

Each header contains a mspg array (tuple) encoded object:

xlHeaderVersion version == 1:

```

  private static final double[] doubleInIntRange = new double[ARRAY_SIZE];
  private static final double[] doubleInLongRange = new double[ARRAY_SIZE];
  private static final double[] positiveDoubles = new double[ARRAY_SIZE];

  @Param({"DOWN", "UP", "FLOOR", "CEILING", "HALF_EVEN", "HALF_UP", "HALF_DOWN"})
  RoundingMode mode;

  @BeforeExperiment
  void setUp() {
    for (int i = 0; i < ARRAY_SIZE; i++) {

 *
 * @author Louis Wasserman
 */
public class IntMathRoundingBenchmark {
  private static final int[] positive = new int[ARRAY_SIZE];
  private static final int[] nonzero = new int[ARRAY_SIZE];
  private static final int[] ints = new int[ARRAY_SIZE];

  @BeforeExperiment
  void setUp() {
    for (int i = 0; i < ARRAY_SIZE; i++) {
      positive[i] = randomPositiveBigInteger(Integer.SIZE - 2).intValue();

  private final int end; // exclusive

  private ImmutableIntArray(int[] array) {
    this(array, 0, array.length);
  }

  private ImmutableIntArray(int[] array, int start, int end) {
    this.array = array;
    this.start = start;
    this.end = end;
  }

  /** Returns the number of values in this array. */
  public int length() {
    return end - start;
  }

  private final int end; // exclusive

  private ImmutableDoubleArray(double[] array) {
    this(array, 0, array.length);
  }

  private ImmutableDoubleArray(double[] array, int start, int end) {
    this.array = array;
    this.start = start;
    this.end = end;
  }

  /** Returns the number of values in this array. */
  public int length() {
    return end - start;
  }

public class UnsignedLongsBenchmark {
  private static final int ARRAY_SIZE = 0x10000;
  private static final int ARRAY_MASK = 0x0ffff;
  private static final Random RANDOM_SOURCE = new Random(314159265358979L);
  private static final long[] longs = new long[ARRAY_SIZE];
  private static final long[] divisors = new long[ARRAY_SIZE];
  private static final String[] decimalStrings = new String[ARRAY_SIZE];

                          values:
                            description: values is an array of string values. If the
                              operator is In or NotIn, the values array must be non-empty.
                              If the operator is Exists or DoesNotExist, the values
                              array must be empty. This array is replaced during a
                              strategic merge patch.

    assertEquals(String[].class, array.getClass());
    assertThat(array).hasLength(2);
    assertNull(array[0]);
  }

  public void testNewArray_fromArray_OfArray() {
    String[][] array = ObjectArrays.newArray(new String[0][0], 1);
    assertEquals(String[][].class, array.getClass());
    assertThat(array).hasLength(1);
    assertNull(array[0]);
  }

          array[i] = counter.getAndIncrement();
        }
        builder.addAll(ImmutableDoubleArray.copyOf(array));
      }
    },
    ADD_LARGER_ARRAY {
      @Override
      void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
        double[] array = new double[RANDOM.nextInt(200) + 200];
        for (int i = 0; i < array.length; i++) {
          array[i] = counter.getAndIncrement();