}
            }

            class PrintAction implements FlowAction<Parameters> {
                interface Parameters extends FlowParameters {
                    @Input Property<String> getText()
                }
                void execute(Parameters parameters) {
                    println(parameters.text.get())
                }
            }

            apply type: FlowActionPlugin

            interface Parameters extends ValueSourceParameters {
                Property<String> getValue()
            }

            @Override String obtain() {
                return parameters.value.orNull
            }
        }

        def vsResult = providers.of(IdentitySource) {
            parameters.value = providers.systemProperty("property")

        Internal.name       | "ConstantBuildService" | "serviceProvider"                  | "parameters.input.get().value"
        Input.name          | "String"               | "serviceProvider.map { it.value} " | "parameters.input.get()"
        Internal.name       | "String"               | "serviceProvider.map { it.value} " | "parameters.input.get()"
    }

            }

            abstract class IsCi : $ValueSource.name<String, Params> {
                override fun obtain(): String? = parameters.value.orNull
            }

            val ciProvider = providers.of(IsCi::class.java) {
                parameters.value.set(providers.systemProperty("test_is_ci"))
            }

            val isCi = ${inputExpression}
            tasks {
                named("jar") {

            }

            abstract class IsCi : $ValueSource.name<String, Params> {
                override fun obtain(): String? = parameters.value.orNull
            }

            val ciProvider = providers.of(IsCi::class.java) {
                parameters.value.set(providers.systemProperty("test_is_ci"))
            }

            val isCi = ${inputExpression}
            tasks {

                ${type} getValue()
            }

            abstract class SomeWorkAction implements WorkAction<SomeParams> {
                void execute() {
                    println("value = \${parameters.value.get()}")
                }
            }

            task worker(type: UsesWorker) {
                value = ${initialValue}
            }
        """

        when:

        outputContains("creating model with parameter='fetch1' for root project 'root'")
        outputContains("creating model with parameter='fetch2' for root project 'root'")
        outputContains("configuring project ':a'")
        outputContains("creating model with parameter='fetch1' for project ':a'")
        outputContains("creating model with parameter='fetch2' for project ':a'")

        and:

                        parameters.targetColor.set('red')
                        parameters.multiplier.set(2)
                    }
                    registerTransform(MakeColor) {
                        from.attribute(color, 'red')
                        to.attribute(color, 'green')
                        parameters.targetColor.set('green')
                        parameters.multiplier.set(1)
                    }

                        parameters.color = flowProviders.buildWorkResult.map {
                            it.failure.present ? 'red' : 'green'
                        }
                    }
                }
            }

            class SetLavaLampColor implements FlowAction<Parameters> {

                interface Parameters extends FlowParameters {

                @TaskAction
                public void exec() {
                    WorkQueue workQueue = getWorkerExecutor().noIsolation();
                    workQueue.submit(SneakyAction.class, parameters -> {})
                }
            }

            def sneakyTask = tasks.register("sneakyTask", SneakyTask) {}

            // Ensure that buildSrc compilation triggers an exec task.