registry
            .registerInstance("foo", new Bean())
            .mutate {
                it.path("foo").type(Bean).action("beans.element.mutable", ModelType.of(MutableValue)) { Bean subject, MutableValue input ->
                    subject.value = input.value
                }
            }
            .registerModelMap("beans", Bean) { it.registerFactory(Bean) { new Bean(name: it) } }
                .mutate {

        def files1 = ['file1.jar', 'file2.jar'].collect { new File(it).canonicalFile }
        def files2 = ['file2.jar', 'file3.jar'].collect { new File(it).canonicalFile }
        def options = new DefaultJavaForkOptions(resolver, fileCollectionFactory, new DefaultJavaDebugOptions())
        def other = new DefaultJavaForkOptions(resolver, fileCollectionFactory, new DefaultJavaDebugOptions())

        when:
        options.with {

    final static ModelType<ComponentSpecFactory> FACTORY_REGISTRY_TYPE = ModelType.of(ComponentSpecFactory)
    ComponentTypeModelRuleExtractor ruleHandler = new ComponentTypeModelRuleExtractor(schemaStore)

    @Override
    Class<? extends Annotation> getAnnotation() { return ComponentType }

    Class<?> ruleClass = Rules

            class MyModel {
                List<String> tasks = []
            }

            class MyPlugin extends RuleSource {
                @Model
                MyModel myModel() {
                    new MyModel()
                }

                @Mutate
                void addTasks(ModelMap<Task> tasks, MyModel myModel) {
                    myModel.tasks.each { n ->
                        tasks.create(n) {

    def listenerManager = new DefaultListenerManager(Scope.Build)
    def isolatableFactory = new DefaultIsolatableFactory(null, TestUtil.managedFactoryRegistry())
    def leaseRegistry = Stub(SharedResourceLeaseRegistry)
    def buildIdentifier = Mock(BuildIdentifier)
    def services = TestUtil.createTestServices { registrations ->
        registrations.addProvider(new ServiceRegistrationProvider() {
            @Provides

    }

    def include(String value) {
        def directives = new RegexBackedCSourceParser().parseSource(new StringReader("#include $value"))
        return directives.includesOnly.first()
    }

    def macro(String name, String value) {
        def directives = new RegexBackedCSourceParser().parseSource(new StringReader("#define ${name} $value"))
        return directives.allMacros.first()
    }

        A, B, C
    }

    final def workerLeaseService = new DefaultWorkerLeaseService(new DefaultResourceLockCoordinationService(), new DefaultWorkerLimits(20))

    def setup() {
        workerLeaseService.startProjectExecution(true)
    }

    StateTransitionController<TestState> controller(TestState initialState) {

    Stack<Object> stack;

    @Test
    @DisplayName("is instantiated with new Stack()")
    void isInstantiatedWithNew() {
        new Stack<>();
    }

    @Nested
    @DisplayName("when new")
    class WhenNew {

        @BeforeEach
        void createNewStack() {
            stack = new Stack<>();
        }

        @Test
        @DisplayName("is empty")

        file.assertIsFile()
        if (os.macOsX) {
            return new OtoolBinaryInfo(file, toolchainUnderTest.runtimeEnv)
        }
        if (os.windows) {
            return DumpbinBinaryInfo.findVisualStudio() ? new DumpbinBinaryInfo(file) : new FileArchOnlyBinaryInfo(file)
        }
        if (ReadelfBinaryInfo.canUseReadelf()) {
            return new ReadelfBinaryInfo(file, toolchainUnderTest.runtimeEnv)
        } else {

    }

    void "platform dependencies are endorsing"() {
        ModuleDependency dep1 = new DefaultExternalModuleDependency("org", "platform", "")
        dep1.attributesFactory = AttributeTestUtil.attributesFactory()
        ModuleDependency dep2 = new DefaultExternalModuleDependency("org", "platform", "")
        dep2.attributesFactory = AttributeTestUtil.attributesFactory()

        when: