* @param resource the resource to track
     * @return resource ID for tracking
     */
    public String registerResource(AutoCloseable resource) {
        if (resource == null) {
            throw new IllegalArgumentException("Resource cannot be null");
        }

        String resourceId = generateResourceId(resource);
        ResourceHolder holder = new ResourceHolder(resourceId, resource, referenceQueue);

  }

  public void testLeastOfIterable_simple_negativeOne() {
    assertThrows(
        IllegalArgumentException.class, () -> numberOrdering.leastOf(asList(3, 4, 5, -1), -1));
  }

  public void testLeastOfIterator_simple_negativeOne() {
    assertThrows(
        IllegalArgumentException.class,
        () -> numberOrdering.leastOf(Iterators.forArray(3, 4, 5, -1), -1));
  }

  }

  public void testLeastOfIterable_simple_negativeOne() {
    assertThrows(
        IllegalArgumentException.class, () -> numberOrdering.leastOf(asList(3, 4, 5, -1), -1));
  }

  public void testLeastOfIterator_simple_negativeOne() {
    assertThrows(
        IllegalArgumentException.class,
        () -> numberOrdering.leastOf(Iterators.forArray(3, 4, 5, -1), -1));
  }

    C current = origin;
    checkNonnegative(distance, "distance");
    for (long i = 0; i < distance; i++) {
      current = next(current);
      if (current == null) {
        throw new IllegalArgumentException(
            "overflowed computing offset(" + origin + ", " + distance + ")");
      }
    }
    return current;
  }

  /**

   * @return a new, empty {@code CompactLinkedHashMap} with enough capacity to hold {@code
   *     expectedSize} elements without resizing
   * @throws IllegalArgumentException if {@code expectedSize} is negative
   */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      CompactLinkedHashMap<K, V> createWithExpectedSize(int expectedSize) {

     * then the exit code will be -1.
     */
    private Result runCommand(String... args) {
        if (args.length == 0) {
            throw new IllegalArgumentException("Cannot execute with no command");
        }

        ByteArrayOutputStream stdout = new ByteArrayOutputStream();
        ByteArrayOutputStream stderr = new ByteArrayOutputStream();

        rpcSid.sub_authority = new int[] { 21, 123, 456, 789 };

        SID domainSid = new SID(rpcSid, SID.SID_TYPE_DOMAIN, "MYDOMAIN", null, true);
        assertThrows(IllegalArgumentException.class, domainSid::getRid);
    }

    /**
     * Test getting the account name.
     */
    @Test
    void testGetAccountName() {
        rpc.sid_t rpcSid = new rpc.sid_t();

   * {@inheritDoc}
   *
   * <p>This method returns a serializable {@code ImmutableSortedSet}.
   *
   * <p>The {@link SortedSet#headSet} documentation states that a subset of a subset throws an
   * {@link IllegalArgumentException} if passed a {@code toElement} greater than an earlier {@code
   * toElement}. However, this method doesn't throw an exception in that situation, but instead
   * keeps the original {@code toElement}.
   */

   * generated builder is equivalent to that returned by {@link #builder}, but may perform better if
   * {@code expectedKeys} is a good estimate.
   *
   * @throws IllegalArgumentException if {@code expectedKeys} is negative
   * @since 33.3.0
   */
  public static <K, V> Builder<K, V> builderWithExpectedKeys(int expectedKeys) {
    checkNonnegative(expectedKeys, "expectedKeys");

     *     case no change will be made.
     * @return this {@code Builder} object
     * @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
    @Override