@Override public Optional<String> getRawConfigurationParameter(String key) { return configurationParameters.get(key); }
Predicate<?> get(ConfigurationParameters configurationParameters, String key) { // @formatter:off return configurationParameters.get(key) .filter(StringUtils::isNotBlank) .map(String::trim) .map(patternString -> { if (DEACTIVATE_ALL_PATTERN.equals(patternString)) { return alwaysDeactivated; } return matchesRegex(patternString); }) .orElse(alwaysActivated); // @formatter:on }
E get(ConfigurationParameters configParams, String key, E defaultValue) { Preconditions.notNull(configParams, "ConfigurationParameters must not be null"); Optional<String> optional = configParams.get(key); String constantName = null; if (optional.isPresent()) { try { constantName = optional.get().trim().toUpperCase(); E value = Enum.valueOf(enumType, constantName); logger.info(() -> String.format("Using %s '%s' set via the '%s' configuration parameter.", enumDisplayName, value, key)); return value; } catch (Exception ex) { // local copy necessary for use in lambda expression String constant = constantName; logger.warn(() -> String.format( "Invalid %s '%s' set via the '%s' configuration parameter. " + "Falling back to the %s default value.", enumDisplayName, constant, key, defaultValue.name())); } } return defaultValue; }
@Override public Optional<String> getConfigurationParameter(String key) { return this.configurationParameters.get(key); } }
@Override public Optional<String> get(String key) { return delegate.get(prefixed(key)); }
@Override public <T> Optional<T> get(String key, Function<String, T> transformer) { return delegate.get(prefixed(key), transformer); }
static ParallelExecutionConfigurationStrategy getStrategy(ConfigurationParameters configurationParameters) { return valueOf(configurationParameters.get(CONFIG_STRATEGY_PROPERTY_NAME).orElse("dynamic").toUpperCase()); }
@Override public ParallelExecutionConfiguration createConfiguration(ConfigurationParameters configurationParameters) { BigDecimal factor = configurationParameters.get(CONFIG_DYNAMIC_FACTOR_PROPERTY_NAME, BigDecimal::new).orElse(BigDecimal.ONE); Preconditions.condition(factor.compareTo(BigDecimal.ZERO) > 0, () -> String.format("Factor '%s' specified via configuration parameter '%s' must be greater than 0", factor, CONFIG_DYNAMIC_FACTOR_PROPERTY_NAME)); int parallelism = Math.max(1, factor.multiply(BigDecimal.valueOf(Runtime.getRuntime().availableProcessors())).intValue()); return new DefaultParallelExecutionConfiguration(parallelism, parallelism, 256 + parallelism, parallelism, KEEP_ALIVE_SECONDS); } },
@Override public ParallelExecutionConfiguration createConfiguration(ConfigurationParameters configurationParameters) { int parallelism = configurationParameters.get(CONFIG_FIXED_PARALLELISM_PROPERTY_NAME, Integer::valueOf).orElseThrow( () -> new JUnitException(String.format("Configuration parameter '%s' must be set", CONFIG_FIXED_PARALLELISM_PROPERTY_NAME))); return new DefaultParallelExecutionConfiguration(parallelism, parallelism, 256 + parallelism, parallelism, KEEP_ALIVE_SECONDS); } },
default <T> Optional<T> get(String key, Function<String, T> transformer) { Preconditions.notNull(transformer, "transformer must not be null"); return get(key).map(input -> { try { return transformer.apply(input);
@Override public ParallelExecutionConfiguration createConfiguration(ConfigurationParameters configurationParameters) { String className = configurationParameters.get(CONFIG_CUSTOM_CLASS_PROPERTY_NAME).orElseThrow( () -> new JUnitException(CONFIG_CUSTOM_CLASS_PROPERTY_NAME + " must be set")); return ReflectionUtils.tryToLoadClass(className) // .andThenTry(strategyClass -> { Preconditions.condition( ParallelExecutionConfigurationStrategy.class.isAssignableFrom(strategyClass), CONFIG_CUSTOM_CLASS_PROPERTY_NAME + " does not implement " + ParallelExecutionConfigurationStrategy.class); return (ParallelExecutionConfigurationStrategy) ReflectionUtils.newInstance(strategyClass); }) // .andThenTry(strategy -> strategy.createConfiguration(configurationParameters)) // .getOrThrow(cause -> new JUnitException( "Could not create configuration for strategy class: " + className, cause)); } };