*/
    public static void validate() {
        LaRequestUtil.getOptionalRequest().map(req -> (WebApiException) req.getAttribute(WEB_API_EXCEPTION)).ifPresent(e -> {
            throw e;
        });
    }

                errors.add(ex)
            }
        }
        openJavaCompilationUnitsByFile.clear()
        openKotlinCompilationUnitsByRoot.clear()
        if (errors.isNotEmpty()) {
            throw Exception("Sources repository did not close cleanly").apply {
                errors.forEach(this::addSuppressed)
            }
        }
    }

    /**
     * @return the source file and it's source root

      } catch (_: InterruptedException) {
        Thread.currentThread().interrupt() // Retain interrupted status.
      }
    }

    if (!::bytes.isInitialized) {
      // May have failed with an IOException
      throw IllegalStateException("Unable to load $path resource.").apply {
        initCause(readFailure)
      }
    }
  }

  abstract val path: Any

  /**

    expectAdded(e0());
  }

  @CollectionFeature.Require(absent = SUPPORTS_ADD)
  @CollectionSize.Require(absent = ZERO)
  /*
   * absent = ZERO isn't required, since unmodList.add() must
   * throw regardless, but it keeps the method name accurate.
   */
  public void testAdd_unsupportedPresent() {
    assertThrows(UnsupportedOperationException.class, () -> getList().add(e0()));
  }

      case NEXT_HIGHER:
        assertEquals(nextHigherIndex, answer);
        return;
      case INVERTED_INSERTION_INDEX:
        assertEquals(-1 - nextHigherIndex, answer);
        return;
    }
    throw new AssertionError();
  }

  public void testWithoutDups() {
    for (KeyPresentBehavior presentBehavior : KeyPresentBehavior.values()) {
      for (KeyAbsentBehavior absentBehavior : KeyAbsentBehavior.values()) {

    }

    @Override
    public Indexed<T> next() {
        return new Indexed<>(iterator.next(), index++);
    }

    @Override
    public void remove() {
        throw new ClUnsupportedOperationException("remove");
    }

        for (final String dialect : this.dialects) {
            bos.write(0x02);
            try {
                bos.write(Strings.getASCIIBytes(dialect));
            } catch (final IOException e) {
                throw new RuntimeCIFSException(e);
            }
            bos.write(0x0);
        }

        System.arraycopy(bos.toByteArray(), 0, dst, dstIndex, bos.size());
        return bos.size();
    }

    @Override

        try {
            return doCleanArgs(args);
        } catch (RuntimeException e) {
            for (String a : args) {
                System.out.println("Arg: '" + a + "'");
            }
            throw e;
        }
    }

    private static String[] doCleanArgs(String[] args) {
        List<String> cleaned = new ArrayList<>();

        StringBuilder currentArg = null;

        for (String arg : args) {

            List<String> cycle = visitCycle(graph, Collections.singleton(to), new HashMap<>(), new LinkedList<>());
            if (cycle != null) {
                // remove edge which introduced cycle
                throw new CycleDetectedException(
                        "Edge between '" + from + "' and '" + to + "' introduces to cycle in the graph", cycle);
            }
        }
    }

    private enum DfsState {
        VISITING,

            lastCommandList = new ArrayList<>(cmdList);

            if (exception instanceof RuntimeException) {
                throw (RuntimeException) exception;
            } else if (exception instanceof InterruptedException) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(exception);
            }

            return new MockJobProcess(exitValue, output);
        }