public static void awaitTerminationUninterruptibly(ExecutorService executor) {
    // TODO(cpovirk): We could optimize this to avoid calling nanoTime() at all.
    verify(awaitTerminationUninterruptibly(executor, Long.MAX_VALUE, NANOSECONDS));
  }

  /**
   * Invokes {@code executor.}{@link ExecutorService#awaitTermination(long, TimeUnit)
   * awaitTermination(long, TimeUnit)} uninterruptibly.
   *

            smb2Response.setTreeId(0);
            assertTrue(smb2Response.isValidTid(), "TID 0 should be valid");

            // Test maximum valid TID
            smb2Response.setTreeId(Integer.MAX_VALUE);
            assertTrue(smb2Response.isValidTid(), "Maximum TID should be valid");

            // Test invalid TID
            smb2Response.setTreeId(-1);

    // Setup
    File file = createTempFile();
    // Test
    assertThrows(
        IllegalArgumentException.class,
        () -> Files.map(file, MapMode.READ_WRITE, (long) Integer.MAX_VALUE + 1));
  }

  public void testGetFileExtension() {
    assertEquals("txt", Files.getFileExtension(".txt"));
    assertEquals("txt", Files.getFileExtension("blah.txt"));

    // Setup
    File file = createTempFile();
    // Test
    assertThrows(
        IllegalArgumentException.class,
        () -> Files.map(file, MapMode.READ_WRITE, (long) Integer.MAX_VALUE + 1));
  }

  public void testGetFileExtension() {
    assertEquals("txt", Files.getFileExtension(".txt"));
    assertEquals("txt", Files.getFileExtension("blah.txt"));

     * @throws NullPointerException if {@code element} is null
     * @throws IllegalArgumentException if {@code occurrences} is negative, or if this operation
     *     would result in more than {@link Integer#MAX_VALUE} occurrences of the element
     */
    @CanIgnoreReturnValue
    public Builder<E> addCopies(E element, int occurrences) {
      contents.add(checkNotNull(element), occurrences);
      return this;
    }

        monitor.leave();
      }
    } else {
      return null;
    }
  }

  // this doc comment is overridden to remove the reference to collections
  // greater in size than Integer.MAX_VALUE
  /**
   * Returns the number of elements in this queue.
   *
   * @return the number of elements in this queue
   */
  @CanIgnoreReturnValue
  @Override
  public int size() {

   * infinite {@code double} values are considered infinitely far away. For example, 2^2000 is not
   * representable as a double, but {@code roundToDouble(BigInteger.valueOf(2).pow(2000), HALF_UP)}
   * will return {@code Double.MAX_VALUE}, not {@code Double.POSITIVE_INFINITY}.
   *
   * <p>For the case of {@link RoundingMode#HALF_EVEN}, this implementation uses the IEEE 754

    }

    directedGraph.addEdge(N2, N1, E21);
    // View should be updated.
    assertThat(transpose.edgesConnecting(N1, N2)).containsExactly(E21);
    assertThat(transpose.edgeConnecting(N1, N2)).hasValue(E21);
    assertThat(transpose.edgeConnectingOrNull(N1, N2)).isEqualTo(E21);
    AbstractNetworkTest.validateNetwork(transpose);
  }

  @Test
  public void inducedSubgraph_graph() {

   * @return the previous count of the element before the operation; possibly zero
   * @throws IllegalArgumentException if {@code occurrences} is negative, or if the resulting amount
   *     would exceed {@link Integer#MAX_VALUE}
   */
  @CanIgnoreReturnValue
  @Override
  public int add(E element, int occurrences) {
    checkNotNull(element);
    if (occurrences == 0) {
      return count(element);
    }

  /**
   * Returns the number of nanoseconds of the given duration without throwing or overflowing.
   *
   * <p>Instead of throwing {@link ArithmeticException}, this method silently saturates to either
   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
   */
  @GwtIncompatible // Duration