rollout_config.AllowForDeviceInXlaLaunch(DeviceType(device_type));
    rollout_config.AllowForDeviceInXlaCompileOnDemand(DeviceType(device_type));

    auto device_factory = DeviceFactory::GetFactory(device_type);
    SessionOptions options;
    std::vector<std::unique_ptr<Device>> devices;
    Status s = device_factory->CreateDevices(
        options, "/job:worker/replica:0/task:0", &devices);

        this.delegate = delegate;
    }

    protected ProjectDependencyInternal create(String path) {
        return factory.create(path);
    }

    protected TypeSafeProjectDependencyFactory getFactory() {
        return factory;
    }

    @Override
    public Path getIdentityPath() {
        return delegate.getIdentityPath();
    }

    @Override
    public Project getDependencyProject() {

            ServiceRegistryFactory serviceRegistryFactory = domainObject -> {
                final Factory<LoggingManagerInternal> loggingManagerFactory = buildServices.getFactory(LoggingManagerInternal.class);
                projectScopeServices = new ProjectScopeServices(buildServices, (ProjectInternal) domainObject, loggingManagerFactory);
                return projectScopeServices;
            };

            ExtractedRuleSource<?> ruleSource = ruleExtractor.extract(ruleSourceType.getConcreteClass());
            Object[] parameters = new Object[2 + inputs.size()];
            parameters[0] = ruleSource.getFactory().create();
            parameters[1] = subjectNode.asImmutable(targetReference.getType(), descriptor).getInstance();
            for (int i = 0; i < inputs.size(); i++) {

    }

    private static void makeServiceVisible(ServiceLocator locator, FilteringClassLoader.Spec classLoaderSpec, Class<?> serviceType) {
        classLoaderSpec.allowClass(locator.getFactory(serviceType).getImplementationClass());
        classLoaderSpec.allowResource("META-INF/services/" + serviceType.getName());
    }

    private static boolean needJaxpImpl() {

                        final MethodRuleDefinition<?, ?> methodRuleDefinition = details.method;
                        final Factory<? extends T> factory = getFactory();
                        return new ContextualizedModelAction<T>(methodRuleDefinition, mappedSubject, inputs, action, factory);
                    }
                }, target);
            }
        }

            return source;
        }

        public ModelType<?> getImplementationType() {
            return implementationType;
        }

        public ImplementationFactory<? super PUBLIC, ?> getFactory() {
            return factory;
        }
    }

    private static class InternalViewRegistration<T> {
        private final ModelRuleDescriptor source;
        private final ModelType<T> internalView;

    override fun <T> service(serviceType: Class<T>): T =
        gradle.services.get(serviceType)

    override fun <T> factory(serviceType: Class<T>): Factory<T> =
        gradle.services.getFactory(serviceType)

    private
    class DefaultVintageGradleBuild(override val state: BuildState) : VintageGradleBuild {
        override val isRootBuild: Boolean
            get() = state is RootBuildState

LogConfigurationExce; public abstract Log getInstance(String) throws LogConfigurationExce; public abstract void release(); public abstract void removeAttribute(String); public abstract void setAttribute(String, Object); public static LogFactory getFactory() throws LogConfigurationExce; public static Log getLog(Class) throws LogConfigurationExce; public static Log getLog(String) throws LogConfigurationExce; public static void release(ClassLoader); public static void releaseAll(); protected static...

        _ * loggingServices.get(OutputEventListener) >> Mock(OutputEventListener)
        Factory<LoggingManagerInternal> loggingManagerFactory = Mock()
        _ * loggingServices.getFactory(LoggingManagerInternal) >> loggingManagerFactory
        _ * loggingManagerFactory.create() >> loggingManager
        StyledTextOutputFactory textOutputFactory = Mock()