class ClientBuildEventGeneratorTest extends Specification {
    def fallback = Mock(BuildOperationListener)
    def consumer = Mock(ProgressEventConsumer)
    def subscriptions = Stub(BuildEventSubscriptions)
    def details = "details"
    def operationId = Stub(OperationIdentifier)
    def parentId = Stub(OperationIdentifier)

    def listenerManager = new DefaultListenerManager(Scope.Build)
    def fileSystemAccess = Mock(FileSystemAccess)
    def cachesDir = tmpDir.file("caches")
    def cacheScopeMapping = new DefaultCacheScopeMapping(cachesDir, GradleVersion.current())
    def cacheRepository = new DefaultUnscopedCacheBuilderFactory(new TestInMemoryCacheFactory())

        when:
        def immutable2 = joined.asImmutable()

        then:
        immutable2.getAttribute(one) == "new fallback"
        immutable2.getAttribute(two) == "new primary"
    }

    def "keySet contains attributes from both fallback and primary"() {
        given:
        def fallback = mutable()
        def primary = mutable()

        }
    }

    def "fetches model for target object with parameter"() {
        def model = new Object()
        def targetElement = new Object()
        def modelElement = Stub(Element)
        def modelView = Stub(GradleBuild)
        def parameterType = ValidParameter
        def parameterInitializer = new Action<ValidParameter>() {
            @Override

        assert file.exists() && file.file

        expect:
        normalize(file) == file
    }

    def "normalizes relative path"() {
        def ancestor = new File(tmpDir.testDirectory, "test")
        def baseDir = new File(ancestor, "base")
        def sibling = new File(ancestor, "sub")
        def child = createFile(new File(baseDir, "a/b/file.txt"))

        expect:
        normalize("a/b/file.txt", baseDir) == child

    }

    def "is equal when all attributes and module version are the same"() {
        def moduleVersion = DefaultModuleVersionIdentifier.newId("group", "module", "version")
        def componentId = DefaultModuleComponentIdentifier.newId(moduleVersion)

        def withClassifier = localArtifactIdentifier(componentId, "name", "type", "ext", 'classifier')

        when:
        def result = manager.withIvy(action)

        then:
        result == "result"

        and:
        1 * action.transform({it != null}) >> "result"
        0 * action._
    }

    def "nested actions are executed against the same Ivy instance"() {
        def action1 = Mock(Action)
        def action2 = Mock(Action)
        def transformer = Mock(Transformer)

class CredentialsProviderFactoryTest extends Specification {

    def providerFactory = Mock(ProviderFactory)
    def factory = new CredentialsProviderFactory(providerFactory)

    def "does not allow non-letters and non-digits for identity"() {
        when:
        factory.provide(PasswordCredentials, (String) identity)

        then:
        def e = thrown(IllegalArgumentException)

        def dir = tmpDir.file("dir").createDir()

        expect:
        def stat = fs.stat(dir)
        stat.type == FileType.Directory
        stat.lastModified == 0
        stat.length == 0
    }

    @Requires(UnitTestPreconditions.Symlinks)
    def "stats symlink"() {
        def file = tmpDir.file("file")
        file.text = "123"
        def link = tmpDir.file("link")

        """
        settingsFile << "include 'sub'"
    }

    def "can run tasks upon Eclipse synchronization"() {
        setup:
        buildFile << "eclipse { synchronizationTasks 'foo' }"

        def projectsLoadedHandler = new IntermediateResultHandlerCollector<Void>()
        def buildFinishedHandler = new IntermediateResultHandlerCollector<EclipseModel>()
        def out = new ByteArrayOutputStream()

        when: