import static org.junit.Assert.fail

class DefaultConventionTest {
    Convention convention

    TestPluginConvention1 convention1
    TestPluginConvention2 convention2

    Instantiator instantiator = TestUtil.instantiatorFactory().decorateLenient()

    @Before void setUp() {
        convention = new DefaultConvention(instantiator)
        convention1 = new TestPluginConvention1()
        convention2 = new TestPluginConvention2()

            ToUpperCase
        )), TestUtil.instantiatorFactory().decorateLenient(), shouldNotFail())
    }

    void withNonCacheableToUpperCaseRule() {
        rule = new InstantiatingAction<Details>(DefaultConfigurableRules.of(DefaultConfigurableRule.of(
            ToUpperCaseNotCached
        )), TestUtil.instantiatorFactory().decorateLenient(), shouldNotFail())
    }

        dsl.asDynamicObject

        then:
        thrown(IllegalStateException)
    }

    static class Thing {}

    def "works for dsl object"() {
        when:
        new DslObject(TestUtil.instantiatorFactory().decorateLenient().newInstance(Thing))

        then:
        notThrown(Exception)
    }

    def "can create a source set"() {
        given:
        def container = new DefaultSourceSetContainer(TestFiles.resolver(), TestFiles.taskDependencyFactory(), TestFiles.fileCollectionFactory(), TestUtil.instantiatorFactory().decorateLenient(), TestUtil.objectFactory(), CollectionCallbackActionDecorator.NOOP)

        when:
        SourceSet set = container.create("main")

        then:
        set instanceof DefaultSourceSet

        def lister = new InstantiatingAction<ComponentMetadataListerDetails>(DefaultConfigurableRules.of(Stub(ConfigurableRule)), TestUtil.instantiatorFactory().inject(), Stub(InstantiatingAction.ExceptionHandler))

    def buildOperationRunner = new TestBuildOperationRunner()
    def buildOperationProgressEmitter = new NoOpBuildOperationProgressEventEmitter()
    def config = new DefaultBuildCacheConfiguration(TestUtil.instantiatorFactory().inject(), [
        new DefaultBuildCacheServiceRegistration(DirectoryBuildCache, TestDirectoryBuildCacheServiceFactory),

class AbstractAuthenticationSupportedRepositoryTest extends Specification {

    AuthSupportedRepository repo() {
        new AuthSupportedRepository(TestUtil.instantiatorFactory().decorateLenient(), new DefaultAuthenticationContainer(TestUtil.instantiatorFactory().decorateLenient(), CollectionCallbackActionDecorator.NOOP))
    }

    def "should configure default password credentials using an action only"() {
        setup:

import org.gradle.util.TestUtil
import spock.lang.Specification

class CreateDefaultFlavorsTest extends Specification {
    def flavorContainer = new DefaultFlavorContainer(TestUtil.instantiatorFactory().decorateLenient(), CollectionCallbackActionDecorator.NOOP)
    def rule = new NativeComponentModelPlugin.Rules()

    def "has a single default flavor when not configured"() {
        when:

                TestFiles.resolver(testDirectory),
                TestFiles.patternSetFactory,
                TestUtil.objectFactory(),
                TestFiles.fileSystem(),
                TestUtil.instantiatorFactory().decorateLenient(),
                TestFiles.documentationRegistry()
        )
    }

    void deletesExtraFilesFromDestinationDirectoryAtTheEndOfVisit() {
        given:
        file("src").with {

import java.lang.annotation.Annotation;
import java.util.Set;

/**
 * A scheme, or strategy, for creating objects.
 *
 * <p>Implementations are provided by a {@link InstantiatorFactory}.</p>
 */
public interface InstantiationScheme {
    /**
     * Returns the set of annotations that are supported by this instantiation scheme for dependency injection.
     */