deleteRecursive(tempDir);
        super.tearDown(testInfo);
    }

    private void deleteRecursive(final Path path) throws IOException {
        if (Files.isDirectory(path)) {
            Files.list(path).forEach(child -> {
                try {
                    deleteRecursive(child);
                } catch (final IOException e) {
                    // ignore
                }
            });
        }

  }

  private fun checkForStartEvent(e: ConnectionEvent) {
    if (eventSequence.isEmpty()) {
      assertThat(e).isInstanceOf(ConnectionEvent.ConnectStart::class.java)
    } else {
      eventSequence.forEach loop@{
        when (e.closes(it)) {
          null -> return

          // no open event
          true -> return

          // found open event

            determineSubProjectClassTimes(testCoverage, buildProjectClassTimes)?.toMutableMap()
                ?: return validSubprojects.map { SmallSubprojectBucket(it, ParallelizationMethod.None) }

        validSubprojects.forEach {
            if (!subProjectToClassTimes.containsKey(it.name)) {
                subProjectToClassTimes[it.name] = emptyList()
            }
        }

            return;
        }

        LOGGER.warn("The following changelog files {} be deleted:", dryRun ? "can" : "will");
        LOGGER.warn("");
        filesToDelete.forEach(file -> LOGGER.warn("\t{}", rootDir.relativize(file.toPath())));

        if (dryRun == false) {
            final Set<File> failedToDelete = deleteHelper.deleteFiles(filesToDelete);

     *
     * @param aggregations the OpenSearch aggregations containing facet data, may be null
     */
    public FacetResponse(final Aggregations aggregations) {
        if (aggregations != null) {
            aggregations.forEach(aggregation -> {
                if (aggregation.getName().startsWith(Constants.FACET_FIELD_PREFIX)) {
                    final Terms termFacet = (Terms) aggregation;
                    fieldList.add(new Field(termFacet));

    public Stream<BuildStep> allPredecessors() {
        return preds(new HashSet<>()).stream();
    }

    private Set<BuildStep> preds(Set<BuildStep> preds) {
        if (preds.add(this)) {
            this.predecessors.forEach(n -> n.preds(preds));
        }
        return preds;
    }

    public boolean isSuccessorOf(BuildStep step) {
        return isSuccessorOf(new HashSet<>(), step);
    }

                    causes.add(e);
                }
            }
        }
        if (causes != null) {
            InvokerException exception = new InvokerException("Unable to close context");
            causes.forEach(exception::addSuppressed);
            throw exception;
        }
    }

    public final void closeContainer() throws Exception {
        if (containerCapsuleManaged) {
            doCloseContainer();

                        return false; // This is the first occurrence
                    }
                })
                .toList();

        // Remove duplicates while preserving formatting
        duplicates.forEach(DomUtils::removeElement);

        return !duplicates.isEmpty();
    }

    private String createDependencyKey(Element dependency) {
        String groupId = dependency.childText(MavenPomElements.Elements.GROUP_ID);

                resolutionStrategy.dependencySubstitution.all {
                    val requested = this.requested as? ModuleComponentSelector ?: return@all
                    keepPatterns.forEach { coordinates, _ ->
                        if ("${requested.group}:${requested.module}" == coordinates) {
                            val updated = DefaultModuleComponentSelector.withAttributes(

        val jarUri = URI.create("jar:${jarFile.toPath().toUri()}")
        FileSystems.newFileSystem(jarUri, emptyMap<String, Any>()).use { jarFileSystem ->
            jarFileSystem.rootDirectories.forEach {
                visitClassDirectory(it, classGraph, classesDir, manifestFile.toPath(), buildReceipt.toPath())
            }
        }
        return classGraph
    }

    private
    fun classGraph() =