ServiceRegistry loggingServices = new DefaultServiceRegistry()
    boolean useCurrentProcess
    BuildActionsFactory factory

    def setup() {
        def factoryLoggingManager = Mock(Factory) { _ * create() >> Mock(LoggingManagerInternal) }
        loggingServices.add(OutputEventListener, Mock(OutputEventListener))

import okhttp3.internal.connection.RoutePlanner
import okhttp3.internal.connection.RoutePlanner.ConnectResult

class FakeRoutePlanner(
  val factory: TestValueFactory = TestValueFactory(),
  val taskFaker: TaskFaker = factory.taskFaker,
) : RoutePlanner, Closeable {
  val pool = factory.newConnectionPool(routePlanner = this)
  val events = LinkedBlockingDeque<String>()
  var canceled = false
  var autoGeneratePlans = false

import org.gradle.api.logging.Logging;
import org.gradle.internal.Factory;
import org.gradle.internal.actor.ActorFactory;
import org.gradle.internal.time.Clock;
import org.gradle.internal.work.WorkerLeaseService;
import org.gradle.process.internal.worker.WorkerProcessFactory;

import java.io.File;
import java.util.ArrayList;

/**
 * The default test class scanner factory.
 */

        registry.addProvider(new ServiceRegistrationProvider() {
            @Provides
            Factory<String> createString(BigDecimal value) {
                return { value.toString() } as Factory
            }

            @Provides
            Factory<Integer> createInteger(Long value) {
                return { 12 } as Factory
            }

            @Provides
            Long createLong() {
                return 2L

0001 0.624 responseBodyEnd
0001 0.624 connectionReleased
0001 0.624 callEnd
```

The `EventListener.Factory` also makes it possible to limit metrics to a subset of calls. This one captures metrics on a random 10%:

```java
class MetricsEventListener extends EventListener {
  private static final Factory FACTORY = new Factory() {
    @Override public EventListener create(Call call) {
      if (Math.random() < 0.10) {

      "No tracing engine factory has been registered with the key '", name,
      "' (available: ");
  // Ensure deterministic (sorted) order in the error message
  std::set<string> factories_sorted;
  for (const auto& factory : GetFactories())
    factories_sorted.insert(factory.first);
  const char* comma = "";
  for (const string& factory : factories_sorted) {
    msg += comma + factory;
    comma = ", ";
  }
  msg += ")";

    private final ProgressLoggerFactory factory;
    private final ProgressLogger parentProgressLogger;
    private final Map<String, ProgressLogger> testWorkerProgressLoggers = new HashMap<String, ProgressLogger>();

    public TestWorkerProgressListener(ProgressLoggerFactory factory, ProgressLogger parentProgressLogger) {
        this.factory = factory;
        this.parentProgressLogger = parentProgressLogger;
    }

    protected ModuleVersionResolveException createCopy() {
        try {
            String message = getMessage();
            return getClass().getConstructor(ComponentSelector.class, Factory.class, Collection.class).newInstance(getSelector(), (Factory<String>) () -> message, resolutions);
        } catch (Exception e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    private final PgpSignatoryFactory factory = new PgpSignatoryFactory();

    private final Map<String, PgpSignatory> signatories = new LinkedHashMap<String, PgpSignatory>();

    @Override
    public PgpSignatory getDefaultSignatory(Project project) {
        return factory.createSignatory(project);
    }

    @Override
    public PgpSignatory getSignatory(String name) {

          .buildOrThrow();

  protected final F factory;
  protected final T data;
  protected final T expected;

  private final String suiteName;
  private final String caseDesc;

  SourceSinkTester(F factory, T data, String suiteName, String caseDesc, Method method) {
    super(method.getName());
    this.factory = checkNotNull(factory);
    this.data = checkNotNull(data);