|| 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() {

        } catch (IllegalArgumentException e) {
            if (e.getCause() instanceof DecodingException) {
                return BASE64URL_DECODER.decode(base64String.trim());
            }
            throw e;
        }
    }

    /**
     * Processes the callback from OpenID Connect provider.
     *
     * @param request the HTTP servlet request
     * @param code the authorization code

   * collection methods are supported. When given an element that doesn't satisfy the predicate, the
   * collection's {@code add()} and {@code addAll()} methods throw an {@link
   * IllegalArgumentException}. When methods such as {@code removeAll()} and {@code clear()} are
   * called on the filtered collection, only elements that satisfy the filter will be removed from

            String id = repo.getId();

            if (id == null || id.isEmpty()) {
                throw new InvalidRepositoryException("Repository identifier missing", "");
            }

            String url = repo.getUrl();

            if (url == null || url.isEmpty()) {
                throw new InvalidRepositoryException("URL missing for repository " + id, id);
            }

   */
  @GwtIncompatible // #isMathematicalInteger, com.google.common.math.DoubleUtils
  static double roundIntermediate(double x, RoundingMode mode) {
    if (!isFinite(x)) {
      throw new ArithmeticException("input is infinite or NaN");
    }
    switch (mode) {
      case UNNECESSARY:
        checkRoundingUnnecessary(isMathematicalInteger(x));
        return x;

      case FLOOR:

            if (StringUtil.isBlank(message)) {
                message = "{}";
            }
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Gets the status.
     *
     * @return the status
     */
    public int getStatus() {
        return status;
    }

                logger.debug("WildcardQuery: query={}, boost={}", query, boost);
            }
            return convertWildcardQuery(context, wildcardQuery, boost);
        }
        throw new InvalidQueryException(messages -> messages.addErrorsInvalidQueryUnknown(UserMessages.GLOBAL_PROPERTY_KEY),
                "Unknown q: " + query.getClass() + " => " + query);
    }

    /**

    private WebConfig webConfig;

    public WebAuthenticationConfig getWebAuthenticationConfig() {
        if (StringUtil.isEmpty(getUsername())) {
            throw new CrawlerSystemException(
                    "Username is empty in WebAuthentication configuration. A valid username must be provided for authentication.");
        }

        switch (type) {
        case METADATA:
            return "metadata";
        case LOGOUT:
            return "logout";
        default:
            throw new IllegalArgumentException("Unknown type: " + type);
        }
    }

            buildScanTags = listOf("Check"),
            subprojects = JsonBasedGradleSubprojectProvider(File("./subprojects.json")),
        )
    val testClassDataJson = File(System.getProperty("inputTestClassDataJson") ?: throw IllegalArgumentException("Input file not found!"))
    val generatedBucketsJson = File(System.getProperty("outputBucketSplitJson", "./test-buckets.json"))