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

        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

      "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 += ")";

import org.gradle.api.UncheckedIOException;
import org.gradle.internal.Factory;

import javax.annotation.Nullable;
import java.io.File;
import java.io.IOException;

public class DefaultTemporaryFileProvider implements TemporaryFileProvider {
    private final Factory<File> baseDirFactory;

    public DefaultTemporaryFileProvider(final Factory<File> fileFactory) {
        this.baseDirFactory = fileFactory;
    }

    }

    @Override
    public <T> Factory<T> getFactory(Class<T> type) {
        assertValidServiceType(type);
        Service provider = getFactoryService(type);
        Factory<T> factory = provider == null ? null : Cast.<Factory<T>>uncheckedCast(provider.get());
        if (factory == null) {

    return new CustomMultimap<>(map, factory);
  }

  private static class CustomMultimap<K extends @Nullable Object, V extends @Nullable Object>
      extends AbstractMapBasedMultimap<K, V> {
    transient Supplier<? extends Collection<V>> factory;

    CustomMultimap(Map<K, Collection<V>> map, Supplier<? extends Collection<V>> factory) {
      super(map);

        DefaultSerializerRegistry registry = new DefaultSerializerRegistry(false);

        BaseSerializerFactory factory = new BaseSerializerFactory();
        Serializer<LogLevel> logLevelSerializer = factory.getSerializerFor(LogLevel.class);
        Serializer<Throwable> throwableSerializer = factory.getSerializerFor(Throwable.class);

        // Log events

class DependencyManagementProjectScopeServices implements ServiceRegistrationProvider {
    void configure(ServiceRegistration registration) {
        registration.add(DefaultExternalResourceFileStore.Factory.class);
        registration.add(DefaultArtifactIdentifierFileStore.Factory.class);
        registration.add(TransformStepNodeDependencyResolver.class);
    }

    /** This is needed in order to get the {@code taskDependencyFactory} from the current project. */

            ImplementationFactory<S, ?> factory = findFactory(implementationClass);
            if (factory == null) {
                throw new IllegalArgumentException(String.format("No factory registered to create an instance of implementation class '%s'.", implementationType));
            }
            this.implementationRegistration = new ImplementationRegistration<S>(source, implementationType, factory);
        }