def consumerSchema = Mock(AttributesSchemaInternal) {
        getConsumerDescribers() >> []
        getFailureDescribers(_) >> []
    }
    def attributeMatcher = Mock(AttributeMatcher)
    def factory = Mock(ArtifactVariantSelector.ResolvedArtifactTransformer)
    def dependenciesResolverFactory = Stub(TransformUpstreamDependenciesResolverFactory)
    def transformedVariantFactory = Mock(TransformedVariantFactory)

        };
    }

    @Provides
    protected ApiTextResourceAdapter.Factory createTextResourceAdapterFactory(TextUriResourceLoader.Factory textUriResourceLoaderFactory, TemporaryFileProvider tempFileProvider) {
        return new ApiTextResourceAdapter.Factory(textUriResourceLoaderFactory, tempFileProvider);
    }

    @Provides
    MavenSettingsProvider createMavenSettingsProvider() {

import org.gradle.api.internal.tasks.properties.InspectionScheme;
import org.gradle.api.internal.tasks.properties.InspectionSchemeFactory;
import org.gradle.initialization.ClassLoaderScopeRegistry;
import org.gradle.internal.Factory;
import org.gradle.internal.build.BuildIncluder;
import org.gradle.internal.event.ListenerManager;
import org.gradle.internal.instantiation.InstantiationScheme;
import org.gradle.internal.instantiation.InstantiatorFactory;

    public DefaultBuildEventsListenerRegistry(
        BuildEventListenerFactory factory,
        ListenerManager listenerManager,
        BuildOperationListenerManager buildOperationListenerManager,
        ExecutorFactory executorFactory
    ) {
        this.factory = factory;
        this.listenerManager = listenerManager;
        this.buildOperationListenerManager = buildOperationListenerManager;

	if err := s.maybeApplyResourceTransformers(c); err != nil {
		return err
	}

	metrics.SetStorageMonitorGetter(monitorGetter(factory))

	c.RESTOptionsGetter = s.CreateRESTOptionsGetter(factory, c.ResourceTransformers)
	return nil
}

func monitorGetter(factory serverstorage.StorageFactory) func() (monitors []metrics.Monitor, err error) {
	return func() (monitors []metrics.Monitor, err error) {
		defer func() {

        private final ModuleComponentArtifactIdentifier artifact;
        private final File mainFile;
        private final Factory<File> signatureFile;
        private final String repositoryName;

        private VerificationEvent(ArtifactKind kind, ModuleComponentArtifactIdentifier artifact, File mainFile, Factory<File> signatureFile, String repositoryName) {
            this.kind = kind;
            this.artifact = artifact;

            return crawlerClientFactory;
        }
        final CrawlerClientFactory factory = creator.get();

        final FileAuthenticationService fileAuthenticationService = ComponentUtil.getComponent(FileAuthenticationService.class);

        //  Parameters
        final Map<String, Object> paramMap = new HashMap<>();
        factory.setInitParameterMap(paramMap);

    Logger.getLogger("javax.net.ssl").fn()
  }

  fun wrap(eventListener: EventListener) = EventListener.Factory { ClientRuleEventListener(eventListener, ::addEvent) }

  fun wrap(eventListenerFactory: EventListener.Factory) =
    EventListener.Factory { call -> ClientRuleEventListener(eventListenerFactory.create(call), ::addEvent) }

  /**

                    final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
                    factory.setFeature(Constants.FEATURE_SECURE_PROCESSING, true);
                    factory.setFeature(Constants.FEATURE_EXTERNAL_GENERAL_ENTITIES, false);
                    factory.setFeature(Constants.FEATURE_EXTERNAL_PARAMETER_ENTITIES, false);
                    factory.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, StringUtil.EMPTY);

     *
     * <p>All objects <b>MUST</b> expose their name as a bean property named "name". The name must be constant for the life of the object.</p>
     *
     * @param elementType The type of objects for the container to contain.
     * @param factory The factory to use to create object instances.