}

    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')

    def "decode fails when boolean cannot be fully read"() {
        given:
        def bytes = truncate { Encoder encoder ->
            encoder.writeBoolean(true)
        }

        when:
        decode(bytes) { Decoder decoder ->
            decoder.readBoolean()
        }

        then:
        thrown(EOFException)
    }

    def "can encode and decode a string"() {
        expect:

        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:

    @Rule
    final SetSystemProperties systemProperties = new SetSystemProperties()

    def cleanup() {
        InstrumentedInputs.discardListener()
    }

    def "notifies listener when system property is used"() {
        def listener = withInstrumentedInputsListener()

        System.setProperty("prop", "value")

        when:
        def result = Instrumented.systemProperty("prop", "consumer")

        then:

        def file = tmpDir.file("missing")
        def outFile = tmpDir.file("out")

        expect:
        def resource = new LocalFileStandInExternalResource(file, TestFiles.fileSystem())
        def result = resource.writeToIfPresent(outFile)
        result == null
        !outFile.exists()
    }

    def "can fail on missing file when copying to file"() {
        def file = tmpDir.file("missing")

            }
            def componentFactory = objects.newInstance(PublishServices).softwareComponentFactory
        """
    }

    def newCompilation(String name, CompilationDetails details, String rootComponentName) {
        def runtimeClasspath = "${name}RuntimeClasspath"
        def implementation = "${name}Implementation"
        def runtimeElements = "${name}RuntimeElements"

        expect:
        def original = "abc"
        def isolated = isolatableFactory.isolate(original)
        isolated instanceof StringValueSnapshot
        isolated.isolate().is(original)
    }

    def "can coerce string value"() {
        expect:
        def original = "abc"
        def isolated = isolatableFactory.isolate(original)
        isolated.coerce(String).is(original)