def "can specify a set of services to inject"() {
        def services = Mock(ServiceLookup)
        _ * services.get(String) >> "value"

        when:
        def value = scheme.withServices(services).instantiator().newInstance(WithServices)

        then:
        value.prop == "value"
    }

    def "can create instances without invoking their constructor to use for deserialization"() {
        when:

        return decoratingLenientScheme.withServices(services).instantiator();
    }

    @Override
    public InstantiationScheme decorateScheme() {
        return decoratingScheme;
    }

    @Override
    public InstanceGenerator decorate(ServiceLookup services) {
        return decoratingScheme.withServices(services).instantiator();
    }

    @Override

    /**
     * Creates a new {@link InstantiationScheme} which creates instances using the given services, based on the configuration of this scheme.
     */
    InstantiationScheme withServices(ServiceLookup services);

    /**
     * Returns the instantiator which creates instances using a default set of services, based on the configuration of this scheme.
     */
    InstanceGenerator instantiator();

            DefaultPluginManager.class,
            get(PluginRegistry.class),
            new PluginInstantiator(
                instantiatorFactory.injectScheme().withServices(this).instantiator(),
                pluginScheme.getInstantiationScheme().withServices(this).instantiator()
            ),
            pluginTarget,
            buildOperationRunner,
            userCodeApplicationContext,
            decorator,

    instantiatorFactory: InstantiatorFactory,
    serviceRegistry: ServiceRegistry,
) {
    private
    val instantiator by lazy {
        instantiatorFactory
            .injectScheme()
            .withServices(injectableServicesOf(serviceRegistry))
            .instantiator()
    }

    fun schedule(scheduled: List<RegisteredFlowAction>) {
        scheduled.forEach { flowAction ->
            instantiator

        // TODO - dedupe logic copied from DefaultBuildServicesRegistry
        this.paramsInstantiator = instantiatorFactory.decorateScheme().withServices(services).instantiator();
        this.specInstantiator = instantiatorFactory.decorateLenientScheme().withServices(services).instantiator();
    }

    @Override

    }

    override fun ReadContext.newBean(generated: Boolean): Any = if (generated) {
        val services = ownerService<ServiceRegistry>()
        instantiationScheme.withServices(services).deserializationInstantiator().newInstance(beanType, Any::class.java)
    } else {
        constructorForSerialization.newInstance()
    }

    override suspend fun ReadContext.readStateOf(bean: Any) {

        this.isolatableFactory = isolatableFactory;
        this.leaseRegistry = leaseRegistry;
        this.paramsInstantiator = instantiatorFactory.decorateScheme().withServices(services).instantiator();
        this.specInstantiator = instantiatorFactory.decorateLenientScheme().withServices(services).instantiator();
        this.listener = listener;
        listenerManager.addListener(new ServiceCleanupListener());
    }

    }

    @Override
    public <T> InstanceFactory<T> forType(Class<T> type) {
        return instantiator.factoryFor(type);
    }

    @Override
    public InstantiationScheme withServices(ServiceLookup services) {
        return new DefaultInstantiationScheme(constructorSelector, classGenerator, services, injectionAnnotations, deserializationConstructorCache);
    }

    @Override

        try {
            Class<T> parameterType = isolationScheme.parameterTypeFor(actionType);
            T parameterObject = parameterType == null ? null : parametersInstantiationScheme.withServices(services).instantiator().newInstance(parameterType);
            registration = Cast.uncheckedNonnullCast(instantiatorFactory.decorateLenient().newInstance(TypedRegistration.class, parameterObject, immutableAttributesFactory));