* higher value than you need can waste space and time, and a significantly lower value can lead
   * to thread contention. But overestimates and underestimates within an order of magnitude do not
   * usually have much noticeable impact. A value of one permits only one thread to modify the cache
   * at a time, but since read operations and cache loading computations can proceed concurrently,

    long start1 = System.currentTimeMillis();
    SmbFile[] files1 = dir.listFiles();
    long time1 = System.currentTimeMillis() - start1;
    
    // Second listing should use cache (much faster)
    long start2 = System.currentTimeMillis();
    SmbFile[] files2 = dir.listFiles();
    long time2 = System.currentTimeMillis() - start2;
    
    assertEquals(files1.length, files2.length);

    assertThat((long) arraysDim1 * arraysDim2).isNotEqualTo((long) (arraysDim1 * arraysDim2));

    double[][] arrays = new double[arraysDim1][];
    // it's shared to avoid using too much memory in tests
    double[] sharedArray = new double[arraysDim2];
    Arrays.fill(arrays, sharedArray);

    try {
      Doubles.concat(arrays);
      fail();
    } catch (IllegalArgumentException expected) {

    assertThat((long) arraysDim1 * arraysDim2).isNotEqualTo((long) (arraysDim1 * arraysDim2));

    boolean[][] arrays = new boolean[arraysDim1][];
    // it's shared to avoid using too much memory in tests
    boolean[] sharedArray = new boolean[arraysDim2];
    Arrays.fill(arrays, sharedArray);

    try {
      Booleans.concat(arrays);
      fail();

   * equivalent (except in the case of overflow) to the call {@code
   * addAll(Collections.nCopies(element, occurrences))}, which would presumably perform much more
   * poorly.
   *
   * @param element the element to add occurrences of; may be null only if explicitly allowed by the
   *     implementation

   * input byte array {@code {0x54, 0x32}} would yield the {@code char} value {@code '\\u5432'}.
   *
   * <p>Arguably, it's preferable to use {@link java.nio.ByteBuffer}; that library exposes much more
   * flexibility at little cost in readability.
   *
   * @throws IllegalArgumentException if {@code bytes} has fewer than 2 elements
   */
  @GwtIncompatible // doesn't work

   * input byte array {@code {0x54, 0x32}} would yield the {@code short} value {@code 0x5432}.
   *
   * <p>Arguably, it's preferable to use {@link java.nio.ByteBuffer}; that library exposes much more
   * flexibility at little cost in readability.
   *
   * @throws IllegalArgumentException if {@code bytes} has fewer than 2 elements
   */
  @GwtIncompatible // doesn't work

    assertThat((long) arraysDim1 * arraysDim2).isNotEqualTo((long) (arraysDim1 * arraysDim2));

    int[][] arrays = new int[arraysDim1][];
    // it's shared to avoid using too much memory in tests
    int[] sharedArray = new int[arraysDim2];
    Arrays.fill(arrays, sharedArray);

    try {
      Ints.concat(arrays);
      fail();
    } catch (IllegalArgumentException expected) {
    }

 * order to {@code [key2, key1]}. The {@link #entries()} iterator returns mutable map entries, and
 * {@link #replaceValues} attempts to preserve iteration order as much as possible.
 *
 * <p>The collections returned by {@link #keySet()} and {@link #asMap()} iterate through the keys in
 * the order they were first added to the multimap. Similarly, {@link #get}, {@link #removeAll}, and

   * input byte array {@code {0x54, 0x32}} would yield the {@code short} value {@code 0x5432}.
   *
   * <p>Arguably, it's preferable to use {@link java.nio.ByteBuffer}; that library exposes much more
   * flexibility at little cost in readability.
   *
   * @throws IllegalArgumentException if {@code bytes} has fewer than 2 elements
   */
  @GwtIncompatible // doesn't work