} catch (NoSuchFieldException impossible) {
      throw new AssertionError(impossible);
    }
  }

  /**
   * Returns an optional enum constant for the given type, using {@link Enum#valueOf}. If the
   * constant does not exist, {@link Optional#absent} is returned. A common use case is for parsing
   * user input or falling back to a default enum constant. For example, {@code

    protected int writeBytesWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;
        if (this.unlocks != null) {
            for (final LockingAndXRange lockingAndXRange : this.unlocks) {
                dstIndex += lockingAndXRange.encode(dst, dstIndex);
            }
        }
        if (this.locks != null) {
            for (final LockingAndXRange lockingAndXRange : this.locks) {

        Collection<E> collection) {
      if (collection instanceof NavigableSet) {
        return Sets.unmodifiableNavigableSet((NavigableSet<E>) collection);
      } else if (collection instanceof SortedSet) {
        return Collections.unmodifiableSortedSet((SortedSet<E>) collection);
      } else if (collection instanceof Set) {
        return Collections.unmodifiableSet((Set<E>) collection);

            executionMode = BuildStep.ExecutionMode.ALWAYS
            scriptContent = if (os == Os.WINDOWS) windowsScript else unixScript
        }
    }
}

fun cleanupPerformanceTestSplits(os: Os): BuildSteps.() -> Unit {
    val unixScript = """
rm -rf $PERFORMANCE_TEST_SPLIT_DIRECTORY_NAME
"""

    val windowsScript = """
if exist $PERFORMANCE_TEST_SPLIT_DIRECTORY_NAME rmdir /s /q $PERFORMANCE_TEST_SPLIT_DIRECTORY_NAME

            if (text == null || text.isEmpty()) {
                return Collections.emptyList();
            }

            List<String> readings = new ArrayList<>();

            if (langs == null || langs.length == 0) {
                readings.add(text.toUpperCase());
            } else {
                for (String lang : langs) {
                    if (japaneseMode && "ja".equals(lang)) {

            throws ArtifactResolutionException, InvalidVersionSpecificationException {
        ScopeArtifactFilter filter;
        if (Artifact.SCOPE_PROVIDED.equals(expectedScope)) {
            filter = new ScopeArtifactFilter(Artifact.SCOPE_COMPILE);
        } else if (Artifact.SCOPE_SYSTEM.equals(expectedScope)) {
            filter = new ScopeArtifactFilter(Artifact.SCOPE_COMPILE);
        } else {

      val returnType = method.returnType
      if (methodName == "supports" && Boolean::class.javaPrimitiveType == returnType) {
        return true // ALPN is supported.
      } else if (methodName == "unsupported" && Void.TYPE == returnType) {
        this.unsupported = true // Peer doesn't support ALPN.
        return null
      } else if (methodName == "protocols" && callArgs.isEmpty()) {

          required: true
        - label: I already checked if it is not related to FastAPI but to [Pydantic](https://github.com/pydantic/pydantic).
          required: true
        - label: I already checked if it is not related to FastAPI but to [Swagger UI](https://github.com/swagger-api/swagger-ui).
          required: true
        - label: I already checked if it is not related to FastAPI but to [ReDoc](https://github.com/Redocly/redoc).

 * with any other implementation of this interface.
 *
 * <p>If you have your own graph implementation based around a custom node type {@code MyNode},
 * which has a method {@code getParents()} that retrieves its predecessors in a graph:
 *
 * {@snippet :
 * someGraphAlgorithm(startNode, MyNode::getParents);
 * }
 *
 * <p>If you have some other mechanism for returning the predecessors of a node, or one that doesn't

        for (AutoCloseable c : cs) {
            if (c != null) {
                try {
                    c.close();
                } catch (Exception e) {
                    if (causes == null) {
                        causes = new ArrayList<>();
                    }
                    causes.add(e);
                }
            }
        }
        if (causes != null) {