final String name = accessToken.getParameterName();
                stream(request.getParameterValues(name)).of(stream -> stream.filter(StringUtil::isNotBlank).forEach(permissionSet::add));
                return OptionalEntity.of(permissionSet);
            }).orElseThrow(() -> new InvalidAccessTokenException("invalid_token", "Invalid token: " + token));

        final long expiry = ComponentUtil.getSystemHelper().getCurrentTimeAsLong() - expiredJobInterval;
        final List<JobLog> list = jobLogBhv.selectList(cb -> {
            cb.query().bool((must, should, mustNot, filter) -> {
                must.setLastUpdated_LessEqual(expiry);
                mustNot.setEndTime_Exists();
            });
        });
        if (!list.isEmpty()) {
            list.forEach(jobLog -> {

                return;
            }
        } else if (Boolean.parseBoolean(ignore)) {
            return;
        }

        // X-Robots-Tag
        responseData.getMetaDataMap().entrySet().stream().filter(e -> X_ROBOTS_TAG.equalsIgnoreCase(e.getKey()) && e.getValue() != null)
                .forEach(e -> {
                    boolean noindex = false;
                    boolean nofollow = false;

				DeleteMarkerReplication:   replication.DeleteMarkerReplication{Status: replication.Enabled},
				DeleteReplication:         replication.DeleteReplication{Status: replication.Enabled},
				Filter:                    replication.Filter{},
				ExistingObjectReplication: replication.ExistingObjectReplication{Status: replication.Enabled},
				SourceSelectionCriteria: replication.SourceSelectionCriteria{

        // ## Assert ##
        assertEquals(before, after);
    }

    private long countTmpFiles() {
        return Arrays.stream(Objects.requireNonNull(Curl.tmpDir.listFiles())).map(File::getName)
                .filter(s -> s.startsWith(PREFIX) && s.endsWith(SUFFIX)).count();
    }

        "-PflakyTests=${determineFlakyTestStrategy(stage)}",
        extraParameters,
        parallelizationMethod.extraBuildParameters
    ).filter { it.isNotBlank() }.joinToString(separator = " ")

    if (parallelizationMethod is ParallelizationMethod.TeamCityParallelTests) {
        tcParallelTests(parallelizationMethod.numberOfBatches)
    }

    features {

                // requireNonNull is safe because the first `size` elements have been filled in.
                requireNonNull(e1);
                requireNonNull(e2);
                return comparator.compare(e1.getKey(), e2.getKey());
              });
          // requireNonNull is safe because the first `size` elements have been filled in.
          Entry<K, V> firstEntry = requireNonNull(entryArray[0]);

    string key(v2_reader_->key());
    (*var_to_shape_map)[key] = TensorShape(entry.shape());
    (*var_to_data_type_map)[key] = DataType(entry.dtype());
  }
  // The returned pointers are owned by the caller.
  return std::make_pair(std::move(var_to_shape_map),
                        std::move(var_to_data_type_map));
}

}  // namespace checkpoint

            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);
        }

        }
    }

    private Optional<MavenProject> findOptionalProjectBySelector(
            List<MavenProject> projects, File reactorDirectory, String selector) {
        return projects.stream()
                .filter(project -> isMatchingProject(project, selector, reactorDirectory))
                .findFirst();
    }

    File getBaseDirectoryFromRequest(MavenExecutionRequest request) {