import org.gradle.api.tasks.PathSensitivity
import org.gradle.api.tasks.TaskAction
import org.gradle.work.DisableCachingByDefault

/**
 * A task used for cleaning up all accepted API changes. The functionality is called whenever the release process initiates "branching".
 */
@DisableCachingByDefault(because = "Not worth caching")
abstract class CleanAcceptedApiChanges extends DefaultTask {

    @PathSensitive(PathSensitivity.ABSOLUTE)

        String prop

        Base() {
            prop = "default"
        }
    }

    static abstract class Impl extends Base {
        Impl() {
            throw new RuntimeException("should not be called")
        }
    }

    static abstract class WithServices {
        @Inject
        abstract String getProp()
    }

        def result = provider.get()

        then:
        result.getResult().getExitValue() == 0
        new String(result.getOutput(), Charset.defaultCharset()) == "output"
        new String(result.getError(), Charset.defaultCharset()) == "error"
    }

    def "execOperations are not called if provider is not queried"() {
        when:
        createProviderOf(ProcessOutputValueSource.class) {
            it.parameters {

        String message = "Hello world!";
    }

    static class FooPluginExtension {
        String foo = "foo"

        void foo(Closure closure) {
            fail("should not be called");
        }
    }

        }
    }

    def "build script can query basic details of projects in a function called from allprojects block"() {
        createDirs("a", "b")
        settingsFile << """
            rootProject.name = "root"
            include("a", "b")
        """
        buildKotlinFile << """

                }
                return DynamicInvokeResult.notFound()
            }
        }
    }

    Object methodMissing(String name, Object params) {
        throw new AssertionError("Should not be called")
    }

                        @Override
                        Object get() {
                            if (concurrentCalls.getAndIncrement() != 0) {
                                throw new IllegalStateException("Factory called concurrently")
                            }
                            return concurrentCalls.decrementAndGet()
                        }
                    })
                }
            }
        }

import org.gradle.model.internal.type.ModelType
import spock.lang.Specification

class InstanceBackedModelRegistrationTest extends Specification {

    def registry = new DefaultModelRegistry(null, null)

    def "action is called"() {
        when:
        def fooReference = ModelReference.of("foo", List)
        def barReference = ModelReference.of("bar", List)

        def descriptor = new SimpleModelRuleDescriptor("foo")

    String groovyProperty

    def groovyMethod(a, b) {
        "groovy:$a.$b".toString()
    }
}

class DynamicGroovyBean {
    
    private holder = null;
    
    Map called = [:]
    
    def propertyMissing(String name) {
        if (name == "foo") {
            return holder;
        } else {
            throw new MissingPropertyException(name, getClass())
        }
    }

            }
        }
    }

    Object propertyMissing(String name) {
        throw new AssertionError("should not be called")
    }

    void propertyMissing(String name, Object value) {
        throw new AssertionError("should not be called")
    }