*
   * <pre>
   * assertEquals("Unable to assign a customer id", Throwables.getRootCause(e).getMessage());
   * </pre>
   *
   * @throws IllegalArgumentException if there is a loop in the causal chain
   */
  public static Throwable getRootCause(Throwable throwable) {
    // Keep a second pointer that slowly walks the causal chain. If the fast pointer ever catches

    testEncodes(base32().withSeparator("*", 4), "foobar", "MZXW*6YTB*OI==*====");
  }

  public void testSeparatorSameAsPadChar() {
    assertThrows(IllegalArgumentException.class, () -> base64().withSeparator("=", 3));

    assertThrows(
        IllegalArgumentException.class, () -> base64().withPadChar('#').withSeparator("!#!", 3));
  }

  public void testAtMostOneSeparator() {

    Files.write(ASCII, temp1, UTF_8);
    assertThrows(IllegalArgumentException.class, () -> Files.copy(temp1, temp2));
    assertEquals(ASCII, Files.toString(temp1, UTF_8));
  }

  public void testCopySameFile() throws IOException {
    File temp = createTempFile();
    Files.write(ASCII, temp, UTF_8);
    assertThrows(IllegalArgumentException.class, () -> Files.copy(temp, temp));

  private static Class<? extends Annotation> asAnnotation(Class<?> clazz) {
    if (clazz.isAnnotation()) {
      return (Class<? extends Annotation>) clazz;
    } else {
      throw new IllegalArgumentException(rootLocaleFormat("%s is not an annotation.", clazz));
    }
  }

  public void testFeatureEnums() throws Exception {
    assertGoodFeatureEnum(CollectionFeature.class);

        }

        final String validationError = getValidationError(badWord);
        if (validationError != null) {
            throw new IllegalArgumentException("Validation error. " + validationError);
        }
        arraySettings.add(BAD_WORD_SETTINGD_KEY, badWord);
    }

    public void delete(final String badWord) {
        if (logger.isDebugEnabled()) {

   *
   * @param values a series of values, which will be converted to {@code double} values (this may
   *     cause loss of precision)
   * @throws IllegalArgumentException if the dataset is empty
   */
  public static double meanOf(Iterable<? extends Number> values) {
    return meanOf(values.iterator());
  }

  /**

                || FAIL_AT_END.equals(failureBehavior)
                || FAIL_NEVER.equals(failureBehavior)) {
            this.failureBehavior = failureBehavior;
        } else {
            throw new IllegalArgumentException("Invalid failure behavior (must be one of: '" + FAIL_FAST + "', '"
                    + FAIL_AT_END + "', '" + FAIL_NEVER + "').");
        }
    }

    public String getFailureBehavior() {

    assertThrows(
        IllegalArgumentException.class, () -> TypeToken.of(Object.class).constructor(constructor));
  }

  public void testConstructor_declaredBySuperclass() throws NoSuchMethodException {
    Constructor<Object> constructor = Object.class.getConstructor();
    assertThrows(
        IllegalArgumentException.class, () -> TypeToken.of(String.class).constructor(constructor));
  }

    final int INITIAL_COUNT = 92384930;
    final int COUNT_TO_ADD = Integer.MAX_VALUE - INITIAL_COUNT + 1;

    when(backingMap.get(KEY)).thenReturn(new AtomicInteger(INITIAL_COUNT));

    assertThrows(IllegalArgumentException.class, () -> multiset.add(KEY, COUNT_TO_ADD));
  }

  /**
   * Simulate some of the races that can happen on add. We can't easily simulate the race that

    return new UnsignedLong(bits);
  }

  /**
   * Returns an {@code UnsignedLong} representing the same value as the specified {@code long}.
   *
   * @throws IllegalArgumentException if {@code value} is negative
   * @since 14.0
   */
  @CanIgnoreReturnValue
  public static UnsignedLong valueOf(long value) {