public Spliterator<E> spliterator() {
      return CollectSpliterators.filter(unfiltered.spliterator(), predicate);
    }

    @Override
    public void forEach(Consumer<? super E> action) {
      checkNotNull(action);
      unfiltered.forEach(
          (E e) -> {
            if (predicate.test(e)) {
              action.accept(e);
            }
          });
    }

    @Override

      }
    }

    fun rethrowIfNotExpected(e: Throwable) {
      versionChecks.forEach { (versionMatcher, failureMatcher) ->
        if (versionMatcher.matches(PlatformVersion) && failureMatcher.matches(e)) {
          return
        }
      }

      throw e
    }

    fun failIfExpected() {
      versionChecks.forEach { (versionMatcher, failureMatcher) ->
        if (versionMatcher.matches(PlatformVersion)) {

    public static Session create() {
        Map<String, String> properties = new HashMap<>();
        // Env variables prefixed with "env."
        System.getenv().forEach((k, v) -> properties.put("env." + k, v));
        // Java System properties
        System.getProperties().forEach((k, v) -> properties.put(k.toString(), v.toString()));
        // create session
        return create(Map.of(), properties);
    }

    /**

            listOf(extraParameters) +
            functionalTestParameters(os, arch)
        ).joinToString(separator = " ")

    killProcessStep(KILL_LEAKED_PROCESSES_FROM_PREVIOUS_BUILDS, os, arch)

    (1..10).forEach { idx ->
        steps {
            gradleWrapper {
                name = "GRADLE_RUNNER_$idx"
                tasks = "%$testTaskParameterName% -PrerunAllTests --tests %$testNameParameterName% %$testTaskOptionsParameterName%"

        val properties = Properties()
        val ret = mutableMapOf<String, MutableList<String>>()
        properties.load(StringReader(content))
        properties.forEach { key, value ->
            val list = ret.getOrDefault(value, mutableListOf())
            list.add(key!!.toString())
            ret[value!!.toString()] = list
        }
        return ret
    }

                must.setLastUpdated_LessEqual(expiry);
                mustNot.setEndTime_Exists();
            });
        });
        if (!list.isEmpty()) {
            list.forEach(jobLog -> {
                jobLog.setJobStatus(Constants.FAIL);
                jobLog.setScriptResult("No response from Job.");
                jobLog.setEndTime(ComponentUtil.getSystemHelper().getCurrentTimeAsLong());

                        && !"clean".equals(getLifecycles(project).peekLast())
                || hasBeenPackagedDuringThisSession(project)) {
            getProjectArtifacts(project).filter(this::isRegularFile).forEach(this::installIntoProjectLocalRepository);
        }
    }

    private void cleanProjectLocalRepository(MavenProject project) {
        try {
            Path artifactPath = getProjectLocalRepo()

			const argvPtrs = [];
			this.argv.forEach((arg) => {
				argvPtrs.push(strPtr(arg));
			});
			argvPtrs.push(0);

			const keys = Object.keys(this.env).sort();
			keys.forEach((key) => {
				argvPtrs.push(strPtr(`${key}=${this.env[key]}`));
			});
			argvPtrs.push(0);

			const argv = offset;
			argvPtrs.forEach((ptr) => {
				this.mem.setUint32(offset, ptr, true);

            String propertyValue = properties.getProperty(REMAINING_PROJECTS);
            Stream.of(propertyValue.split(PROPERTY_DELIMITER))
                    .filter(str -> str != null && !str.isEmpty())
                    .forEach(request.getProjectActivation()::activateOptionalProject);
            LOGGER.info("Resuming from {} due to the --resume / -r feature.", propertyValue);
        }
    }

            responseData.setLastModified(statObject.lastModified() == null ? null : Date.from(statObject.lastModified().toInstant()));
            responseData.setMimeType(statObject.contentType());
            statObject.headers().forEach(e -> responseData.addMetaData(e.getFirst(), e.getSecond()));

            if (contentLengthHelper != null) {
                final long maxLength = contentLengthHelper.getMaxLength(responseData.getMimeType());