)
        }
    }

    @Test
    fun `val domainObject by registering { }`() {

        val domainObjectProvider = mockDomainObjectProviderFor(DomainObject())
        val container = mock<NamedDomainObjectContainer<DomainObject>> {
            on { register(eq("domainObject"), any<Action<DomainObject>>()) } doReturn domainObjectProvider
        }

        container {

                        inputFile), e);
            }
        } else {
            domainObject = generator.defaultInstance();
        }
        beforeConfigured.execute(domainObject);
        generator.configure(domainObject);
        afterConfigured.execute(domainObject);

        generator.write(domainObject, getOutputFile());
    }

    @Inject
    protected Instantiator getInstantiator() {

    data class DomainObject(var foo: String? = null, var bar: Boolean? = null)

    @Test
    fun `can use monomorphic container api`() {

        val alice = DomainObject()
        val bob = DomainObject()
        val john = DomainObject()
        val marty = mockDomainObjectProviderFor(DomainObject())
        val doc = mockDomainObjectProviderFor(DomainObject())

    /**
     * Creates the services for the given domain object. The caller is responsible for closing the registry.
     *
     * @param domainObject The domain object.
     * @return The registry containing the services for the domain object.
     */
    ServiceRegistry createFor(Object domainObject);

    public ServiceRegistry createFor(Object domainObject) {
        if (domainObject instanceof GradleInternal) {
            GradleScopeServices gradleServices = new GradleScopeServices(services);
            registries.add(gradleServices);
            return gradleServices;
        }
        throw new IllegalArgumentException(String.format("Cannot create services for unknown domain object of type %s.", domainObject.getClass().getSimpleName()));
    }

        private SettingsScopeServices services;

        @Override
        public ServiceRegistry createFor(Object domainObject) {
            services = new SettingsScopeServices(buildScopeServices, (SettingsInternal) domainObject);
            return services;
        }
    }

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

            lateinit var services: SettingsScopeServices
            val serviceRegistryFactory = object : ServiceRegistryFactory {
                override fun createFor(domainObject: Any): ServiceRegistry {
                    services = SettingsScopeServices(service<ServiceRegistry>(), domainObject as SettingsInternal)
                    return services
                }
            }
            val settings = service<Instantiator>().newInstance(