Memoize configuration parameters that are costly to create

Author: henri-tremblay

cucumber-junit-platform-engine/src/main/java/io/cucumber/junit/platform/engine/CucumberConfiguration.java

@@ -29,6 +29,8 @@
 import java.util.Locale;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
@@ -62,6 +64,7 @@ class CucumberConfiguration implements
 
     private final ConfigurationParameters configurationParameters;
     private final DiscoveryIssueReporter issueReporter;
+    private final ConcurrentHashMap<String, Optional<?>> memoizing = new ConcurrentHashMap<>();
 
     CucumberConfiguration(ConfigurationParameters configurationParameters, DiscoveryIssueReporter issueReporter) {
         this.configurationParameters = requireNonNull(configurationParameters);
@@ -70,7 +73,7 @@ class CucumberConfiguration implements
 
     @Override
     public List<Plugin> plugins() {
-        List<Plugin> plugins = configurationParameters.get(PLUGIN_PROPERTY_NAME, s -> Arrays.stream(s.split(","))
+        List<Plugin> plugins = memoize(PLUGIN_PROPERTY_NAME, s -> Arrays.stream(s.split(","))
                 .map(String::trim)
                 .map(PluginOption::parse)
                 .map(pluginOption -> (Plugin) pluginOption)
@@ -131,18 +134,22 @@ public boolean isWip() {
         return false;
     }
 
+    @SuppressWarnings("unchecked")
+    private <T> Optional<T> memoize(String key, Function<? super String, ? extends @Nullable T> transformer) {
+        return (Optional<T>) memoizing.computeIfAbsent(key, k -> configurationParameters.get(k, transformer));
+    }
+
     Optional<Expression> tagFilter() {
-        return configurationParameters.get(FILTER_TAGS_PROPERTY_NAME, TagExpressionParser::parse);
+        return memoize(FILTER_TAGS_PROPERTY_NAME, TagExpressionParser::parse);
     }
 
     Optional<Pattern> nameFilter() {
-        return configurationParameters.get(FILTER_NAME_PROPERTY_NAME, Pattern::compile);
+        return memoize(FILTER_NAME_PROPERTY_NAME, Pattern::compile);
     }
 
     @Override
     public List<URI> getGlue() {
-        return configurationParameters
-                .get(GLUE_PROPERTY_NAME, s -> Arrays.asList(s.split(",")))
+        return memoize(GLUE_PROPERTY_NAME, s -> Arrays.asList(s.split(",")))
                 .orElse(Collections.singletonList(CLASSPATH_SCHEME_PREFIX))
                 .stream()
                 .map(String::trim)
@@ -159,22 +166,19 @@ public boolean isDryRun() {
 
     @Override
     public SnippetType getSnippetType() {
-        return configurationParameters
-                .get(SNIPPET_TYPE_PROPERTY_NAME, SnippetTypeParser::parseSnippetType)
+        return memoize(SNIPPET_TYPE_PROPERTY_NAME, SnippetTypeParser::parseSnippetType)
                 .orElse(SnippetType.UNDERSCORE);
     }
 
     @Override
     public @Nullable Class<? extends ObjectFactory> getObjectFactoryClass() {
-        return configurationParameters
-                .get(OBJECT_FACTORY_PROPERTY_NAME, ObjectFactoryParser::parseObjectFactory)
+        return memoize(OBJECT_FACTORY_PROPERTY_NAME, ObjectFactoryParser::parseObjectFactory)
                 .orElse(null);
     }
 
     @Override
     public @Nullable Class<? extends UuidGenerator> getUuidGeneratorClass() {
-        return configurationParameters
-                .get(UUID_GENERATOR_PROPERTY_NAME, UuidGeneratorParser::parseUuidGenerator)
+        return memoize(UUID_GENERATOR_PROPERTY_NAME, UuidGeneratorParser::parseUuidGenerator)
                 .orElse(null);
     }
 
@@ -185,8 +189,7 @@ boolean isParallelExecutionEnabled() {
     }
 
     NamingStrategy namingStrategy() {
-        return configurationParameters
-                .get(JUNIT_PLATFORM_NAMING_STRATEGY_PROPERTY_NAME, DefaultNamingStrategyProvider::getStrategyProvider)
+        return memoize(JUNIT_PLATFORM_NAMING_STRATEGY_PROPERTY_NAME, DefaultNamingStrategyProvider::getStrategyProvider)
                 .map(this::reportIssueIfSurefireStrategyIsUsed)
                 .orElse(DefaultNamingStrategyProvider.SHORT)
                 .create(configurationParameters);
@@ -203,7 +206,7 @@ private DefaultNamingStrategyProvider reportIssueIfSurefireStrategyIsUsed(Defaul
     }
 
     Set<FeatureWithLinesSelector> featuresWithLines() {
-        return configurationParameters.get(FEATURES_PROPERTY_NAME,
+        return memoize(FEATURES_PROPERTY_NAME,
             s -> Arrays.stream(s.split(","))
                     .map(String::trim)
                     .map(FeatureWithLines::parse)
@@ -213,7 +216,7 @@ Set<FeatureWithLinesSelector> featuresWithLines() {
     }
 
     ExecutionMode getExecutionModeFeature() {
-        return configurationParameters.get(EXECUTION_MODE_FEATURE_PROPERTY_NAME,
+        return memoize(EXECUTION_MODE_FEATURE_PROPERTY_NAME,
             value -> ExecutionMode.valueOf(value.toUpperCase(Locale.ROOT)))
                 .orElse(ExecutionMode.CONCURRENT);
     }

cucumber-junit-platform-engine/src/test/java/io/cucumber/junit/platform/engine/CucumberConfigurationTest.java

@@ -4,6 +4,7 @@
 import io.cucumber.core.eventbus.IncrementingUuidGenerator;
 import io.cucumber.core.plugin.Options;
 import io.cucumber.core.snippets.SnippetType;
+import io.cucumber.tagexpressions.Expression;
 import org.junit.jupiter.api.Test;
 import org.junit.platform.engine.ConfigurationParameters;
 import org.junit.platform.engine.DiscoveryIssue;
@@ -13,10 +14,13 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
+import java.util.regex.Pattern;
 
 import static java.util.stream.Collectors.toList;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.sameInstance;
 import static org.hamcrest.collection.IsEmptyCollection.empty;
 import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
 import static org.hamcrest.core.IsIterableContaining.hasItem;
@@ -193,4 +197,23 @@ void uuidGenerator() {
         assertThat(new CucumberConfiguration(configurationParameters, issueReporter).getUuidGeneratorClass(),
             is(IncrementingUuidGenerator.class));
     }
+
+    @Test
+    void tagFilter() {
+        ConfigurationParameters tags = new MapConfigurationParameters(Constants.FILTER_TAGS_PROPERTY_NAME, "@foo");
+        CucumberConfiguration cucumberConfiguration = new CucumberConfiguration(tags, issueReporter);
+        Optional<Expression> expression = cucumberConfiguration.tagFilter();
+        assertTrue(expression.orElseThrow().evaluate(List.of("@foo")));
+        assertThat(expression, sameInstance(cucumberConfiguration.tagFilter()));
+    }
+
+    @Test
+    void nameFilter() {
+        ConfigurationParameters nameFilter = new MapConfigurationParameters(Constants.FILTER_NAME_PROPERTY_NAME,
+            ".*foo.*");
+        CucumberConfiguration cucumberConfiguration = new CucumberConfiguration(nameFilter, issueReporter);
+        Optional<Pattern> pattern = cucumberConfiguration.nameFilter();
+        assertTrue(pattern.orElseThrow().matcher("aaa foo zzz").matches());
+        assertThat(pattern, sameInstance(cucumberConfiguration.nameFilter()));
+    }
 }