buildFile '''
            import org.gradle.api.flow.*
            import org.gradle.api.services.*
            import java.util.concurrent.atomic.AtomicInteger

            class FlowActionPlugin implements Plugin<Project> {
                final FlowScope flowScope
                final FlowProviders flowProviders
                @Inject FlowActionPlugin(FlowScope flowScope, FlowProviders flowProviders) {

         given:
         def configurationCache = newConfigurationCacheFixture()

         buildFile("""
            import org.gradle.api.provider.*

            abstract class GreetValueSource implements ValueSource<String, ValueSourceParameters.None> {
                String obtain() {
                    return "Hello!"
                }
            }

            abstract class MyTask extends DefaultTask {

        buildFile << """
            class Placeholder implements Serializable {
                String value

                private Object readResolve() {
                    return new OtherBean(prop: "[\$value]")
                }
            }

            class OtherBean implements Serializable {
                String prop

                private Object writeReplace() {

        @Override
        ProviderInternal<String> wrapProviderWithProviderUnderTest(ProviderInternal<String> baseProvider) {
            return new OrElseProvider<String>(baseProvider, Providers.of("B"))
        }
    }

    static class OrElseProviderRightCircularChainEvaluationTest extends CircularChainEvaluationSpec<String> implements UsesStringProperty {
        @Override

package org.gradle.internal.cc.impl

import org.gradle.api.tasks.TasksWithInputsAndOutputs

import javax.inject.Inject

class ConfigurationCacheWorkerApiIntegrationTest extends AbstractConfigurationCacheIntegrationTest implements TasksWithInputsAndOutputs {
    def "task can wire input #type with fixed value to worker action parameter property"() {
        buildFile << """
            import ${Inject.name}

    def "BuildOperationListener build service is instantiated only once per build"() {
        given:
        buildFile """
            abstract class ListenerService
                implements $BuildService.name<${BuildServiceParameters.name}.None>, $BuildOperationListener.name {

                public ListenerService() {
                    println('onInstantiated')
                }

     * classloader, the proxy class executes the given action.
     */
    def <T> Action<T> serializable(Action<T> action, ClassLoader target) {
        String src = """
class TestAction implements ${Action.class.name}, ${Serializable.class.name}
{
    Object key

    void execute(Object target) {
        def action = ${SerializableMockHelper.class.name}.ACTIONS.remove(key)
        action.execute(target)
    }

package org.gradle.test

/**
 * This is a groovy class.
 */
class GroovyClass extends A implements CombinedInterface, JavaInterface {
    /**
     * A groovy property.
     */
    CombinedInterface groovyProp

    /**
     * A read-only groovy property.
     */
    final String readOnlyGroovyProp

    /**
     * An array property.
     */
    def String[] arrayProp

    private def ignoreMe1;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.snapshot.impl

class Bean implements Serializable {
    String prop

    }

    static interface BuildWithSystemPropertyDefined {

        void setup(AbstractIntegrationSpec spec, String propertyKey)

        String propertyValue()
    }

    static class RootBuild implements BuildWithSystemPropertyDefined {

        @Override
        void setup(AbstractIntegrationSpec spec, String propertyKey) {