Add custom UuidGenerator to Runtime.Builder (#3039)

Currently the UuidGenerator is looked up by SPI when creating the event
bus. This requires the UuidGenerator to be part of the classloader what
might not always be the case.

This now adds an option to set an actual instance for the UuidGenerator
and uses that in case it is specified.

Co-authored-by: Christoph Läubrich <[email protected]>
Co-authored-by: M.P. Korstanje <[email protected]>

Author: 3 people

CHANGELOG.md

@@ -20,6 +20,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 - [Core] Intellij prints summary printed when executing concurrently ([#3049](https://github.com/cucumber/cucumber-jvm/pull/3049) M.P. Korstanje)
 
+### Added
+- [Core] Add custom UuidGenerator to Runtime.Builder ([#3039](https://github.com/cucumber/junit-xml-formatter/pull/3039) Christoph Läubrich, M.P. Korstanje)
+
+
 ## [7.27.1] - 2025-08-17
 ### Fixed
 - [Core] Format time in JUnit XML report as `xs:float` ([junit-xml-formatter/#83](https://github.com/cucumber/junit-xml-formatter/pull/83) M.P. Korstanje)

cucumber-core/src/main/java/io/cucumber/core/runtime/Runtime.java

@@ -1,6 +1,7 @@
 package io.cucumber.core.runtime;
 
 import io.cucumber.core.eventbus.EventBus;
+import io.cucumber.core.eventbus.UuidGenerator;
 import io.cucumber.core.feature.FeatureParser;
 import io.cucumber.core.filter.Filters;
 import io.cucumber.core.gherkin.Feature;
@@ -117,96 +118,141 @@ public static class Builder {
         private Supplier<ClassLoader> classLoader = ClassLoaders::getDefaultClassLoader;
         private RuntimeOptions runtimeOptions = RuntimeOptions.defaultOptions();
         private BackendSupplier backendSupplier;
+        private ObjectFactorySupplier objectFactorySupplier;
         private FeatureSupplier featureSupplier;
         private List<Plugin> additionalPlugins = emptyList();
+        private Supplier<UuidGenerator> uuidGeneratorSupplier;
 
         private Builder() {
         }
 
-        public Builder withRuntimeOptions(final RuntimeOptions runtimeOptions) {
+        public Builder withRuntimeOptions(RuntimeOptions runtimeOptions) {
             this.runtimeOptions = runtimeOptions;
             return this;
         }
 
-        public Builder withClassLoader(final Supplier<ClassLoader> classLoader) {
+        public Builder withClassLoader(Supplier<ClassLoader> classLoader) {
             this.classLoader = classLoader;
             return this;
         }
 
-        public Builder withBackendSupplier(final BackendSupplier backendSupplier) {
+        public Builder withBackendSupplier(BackendSupplier backendSupplier) {
             this.backendSupplier = backendSupplier;
             return this;
         }
 
-        public Builder withFeatureSupplier(final FeatureSupplier featureSupplier) {
+        public Builder withObjectFactorySupplier(ObjectFactorySupplier objectFactorySupplier) {
+            this.objectFactorySupplier = objectFactorySupplier;
+            return this;
+        }
+
+        public Builder withFeatureSupplier(FeatureSupplier featureSupplier) {
             this.featureSupplier = featureSupplier;
             return this;
         }
 
-        public Builder withAdditionalPlugins(final Plugin... plugins) {
+        public Builder withUuidGeneratorSupplier(Supplier<UuidGenerator> uuidGenerator) {
+            this.uuidGeneratorSupplier = uuidGenerator;
+            return this;
+        }
+
+        public Builder withAdditionalPlugins(Plugin... plugins) {
             this.additionalPlugins = Arrays.asList(plugins);
             return this;
         }
 
-        public Builder withEventBus(final EventBus eventBus) {
+        public Builder withEventBus(EventBus eventBus) {
             this.eventBus = eventBus;
             return this;
         }
 
         public Runtime build() {
-            final ObjectFactoryServiceLoader objectFactoryServiceLoader = new ObjectFactoryServiceLoader(classLoader,
-                runtimeOptions);
-
-            final ObjectFactorySupplier objectFactorySupplier = runtimeOptions.isMultiThreaded()
-                    ? new ThreadLocalObjectFactorySupplier(objectFactoryServiceLoader)
-                    : new SingletonObjectFactorySupplier(objectFactoryServiceLoader);
-
-            final BackendSupplier backendSupplier = this.backendSupplier != null
-                    ? this.backendSupplier
-                    : new BackendServiceLoader(this.classLoader, objectFactorySupplier);
+            EventBus eventBus = synchronize(createEventBus());
+            ExitStatus exitStatus = createPluginsAndExitStatus(eventBus);
+            RunnerSupplier runnerSupplier = createRunnerSupplier(eventBus);
+            CucumberExecutionContext context = new CucumberExecutionContext(eventBus, exitStatus, runnerSupplier);
+            Predicate<Pickle> filter = new Filters(runtimeOptions);
+            int limit = runtimeOptions.getLimitCount();
+            FeatureSupplier featureSupplier = createFeatureSupplier(eventBus);
+            ExecutorService executor = createExecutorService();
+            PickleOrder pickleOrder = runtimeOptions.getPickleOrder();
+            return new Runtime(exitStatus, context, filter, limit, featureSupplier, executor, pickleOrder);
+        }
 
-            final Plugins plugins = new Plugins(new PluginFactory(), runtimeOptions);
-            for (final Plugin plugin : additionalPlugins) {
-                plugins.addPlugin(plugin);
-            }
-            final ExitStatus exitStatus = new ExitStatus(runtimeOptions);
+        private ExitStatus createPluginsAndExitStatus(EventBus eventBus) {
+            Plugins plugins = createPlugins();
+            ExitStatus exitStatus = new ExitStatus(runtimeOptions);
             plugins.addPlugin(exitStatus);
 
-            if (this.eventBus == null) {
-                final UuidGeneratorServiceLoader uuidGeneratorServiceLoader = new UuidGeneratorServiceLoader(
-                    classLoader,
-                    runtimeOptions);
-                this.eventBus = new TimeServiceEventBus(Clock.systemUTC(),
-                    uuidGeneratorServiceLoader.loadUuidGenerator());
-            }
-            final EventBus eventBus = synchronize(this.eventBus);
-
             if (runtimeOptions.isMultiThreaded()) {
                 plugins.setSerialEventBusOnEventListenerPlugins(eventBus);
             } else {
                 plugins.setEventBusOnEventListenerPlugins(eventBus);
             }
+            return exitStatus;
+        }
 
-            final RunnerSupplier runnerSupplier = runtimeOptions.isMultiThreaded()
+        private RunnerSupplier createRunnerSupplier(EventBus eventBus) {
+            ObjectFactorySupplier objectFactorySupplier = createObjectFactorySupplier();
+            BackendSupplier backendSupplier = createBackendSupplier(objectFactorySupplier);
+            return runtimeOptions.isMultiThreaded()
                     ? new ThreadLocalRunnerSupplier(runtimeOptions, eventBus, backendSupplier, objectFactorySupplier)
                     : new SingletonRunnerSupplier(runtimeOptions, eventBus, backendSupplier, objectFactorySupplier);
+        }
 
-            final ExecutorService executor = runtimeOptions.isMultiThreaded()
-                    ? Executors.newFixedThreadPool(runtimeOptions.getThreads(), new CucumberThreadFactory())
-                    : new SameThreadExecutorService();
+        private ObjectFactorySupplier createObjectFactorySupplier() {
+            if (this.objectFactorySupplier != null) {
+                return objectFactorySupplier;
+            }
+            ObjectFactoryServiceLoader objectFactoryServiceLoader = new ObjectFactoryServiceLoader(classLoader,
+                runtimeOptions);
+            return runtimeOptions.isMultiThreaded()
+                    ? new ThreadLocalObjectFactorySupplier(objectFactoryServiceLoader)
+                    : new SingletonObjectFactorySupplier(objectFactoryServiceLoader);
+        }
 
-            final FeatureParser parser = new FeatureParser(eventBus::generateId);
+        private BackendSupplier createBackendSupplier(ObjectFactorySupplier objectFactorySupplier) {
+            return this.backendSupplier != null
+                    ? this.backendSupplier
+                    : new BackendServiceLoader(this.classLoader, objectFactorySupplier);
+        }
 
-            final FeatureSupplier featureSupplier = this.featureSupplier != null
-                    ? this.featureSupplier
-                    : new FeaturePathFeatureSupplier(classLoader, runtimeOptions, parser);
+        private EventBus createEventBus() {
+            if (this.eventBus != null) {
+                return this.eventBus;
+            }
+            UuidGenerator uuidGenerator = createUuidGenerator();
+            return new TimeServiceEventBus(Clock.systemUTC(), uuidGenerator);
+        }
 
-            final Predicate<Pickle> filter = new Filters(runtimeOptions);
-            final int limit = runtimeOptions.getLimitCount();
-            final PickleOrder pickleOrder = runtimeOptions.getPickleOrder();
-            final CucumberExecutionContext context = new CucumberExecutionContext(eventBus, exitStatus, runnerSupplier);
+        private UuidGenerator createUuidGenerator() {
+            if (uuidGeneratorSupplier != null) {
+                return uuidGeneratorSupplier.get();
+            } else {
+                return new UuidGeneratorServiceLoader(classLoader, runtimeOptions).loadUuidGenerator();
+            }
+        }
 
-            return new Runtime(exitStatus, context, filter, limit, featureSupplier, executor, pickleOrder);
+        private FeatureSupplier createFeatureSupplier(EventBus eventBus) {
+            if (this.featureSupplier != null) {
+                return this.featureSupplier;
+            }
+            FeatureParser parser = new FeatureParser(eventBus::generateId);
+            return new FeaturePathFeatureSupplier(classLoader, runtimeOptions, parser);
+        }
+
+        private ExecutorService createExecutorService() {
+            return runtimeOptions.isMultiThreaded()
+                    ? Executors.newFixedThreadPool(runtimeOptions.getThreads(), new CucumberThreadFactory())
+                    : new SameThreadExecutorService();
+        }
+
+        private Plugins createPlugins() {
+            Plugins plugins = new Plugins(new PluginFactory(), runtimeOptions);
+            for (Plugin plugin : additionalPlugins) {
+                plugins.addPlugin(plugin);
+            }
+            return plugins;
         }
 
     }