class VisualStudioSoftwareModelSingleProjectIntegrationTest extends AbstractVisualStudioIntegrationSpec {
    Set<String> projectConfigurations = ['win32Debug', 'win32Release', 'x64Debug', 'x64Release'] as Set

    def app = new CppHelloWorldApp()

    def setup() {
        assumeFalse(toolChain.meets(WINDOWS_GCC))

        settingsFile << """
            rootProject.name = 'app'
        """
        buildFile << """

                @Model
                void strings(List<String> s) {}

                @Rules
                void rules(OtherRules rules, List<String> s) {
                    throw new RuntimeException("broken")
                }
            }

            class OtherRules extends RuleSource {
            }

            apply plugin: MyPlugin
        '''

        expect:

        getIdentityPath() >> Path.path(":path")
    }
    def registry = new TestProjectPublicationRegistry()
    def projectConfigurer = Mock(ProjectConfigurer)
    def projects = Mock(ProjectStateRegistry)

    def setup() {
        project.displayName >> "<project>"
        projects.stateFor(project.identityPath) >> project.owner
    }

    def resolver = new DefaultProjectDependencyPublicationResolver(registry, projectConfigurer, projects)

import static java.util.stream.Collectors.groupingBy
import static java.util.stream.Collectors.mapping

class TaskCreationBuildOperationIntegrationTest extends AbstractIntegrationSpec {

    def buildOperations = new BuildOperationsFixture(executer, testDirectoryProvider)

    def "configure actions for eager creation are nested in realization build op"() {
        buildFile << """
            tasks.all {

      </key-servers>
   </configuration>
</verification-metadata>
"""
        then:
        verifier.configuration.keyServers == [
            new URI("https://pgp.key-server.io"),
            new URI("hkp://keys.openpgp.org")
        ]
    }
    def "parses trusted artifacts"() {
        when:
        parse """<?xml version="1.0" encoding="UTF-8"?>
<verification-metadata>

        when:
        directoryHeader.deleteDir()
        directoryHeader << '#pragma message("NEW directory named header")'
        and:
        executer.withArgument("--info")
        run "mainExecutable"
        then:
        executedAndNotSkipped compileTask
        and:
        outputs.recompiledFile sourceFile
        outputContains("NEW directory named header")

    }

    @ToBeFixedForConfigurationCache

    ) {
        def doc = actualDocument as DeclarativeDocument
        def parsed = ParserKt.parse(expectedDocumentText)
        def languageTree = new DefaultLanguageTreeBuilder().build(
            parsed, new SourceIdentifier("test")
        )
        def expectedDocument = LanguageTreeToDomKt.toDocument(languageTree)
        DataStructuralEqualityKt.structurallyEqualsAsData(doc, expectedDocument)

                @Output${files ? "Files" : "Directories"} FileCollection out

                @TaskAction def exec() {
                    out.each { it${files ? ".text = 'data' + it.name" : ".mkdirs(); new File(it, 'contents').text = 'data' + it.name"} }
                }
            }

            task myTask(type: MyTask) {
                if (providers.gradleProperty("reverse").isPresent()) {

        def mockSftpClient2 = Mock(LockableSftpClient)

        given:
        URI uri1 = new URI('http://localhost:22/repo1')
        URI uri2 = new URI('http://localhost:22/repo2')
        PasswordCredentials credentials1 = new DefaultPasswordCredentials('sftp1', 'sftp1')
        PasswordCredentials credentials2 = new DefaultPasswordCredentials('sftp2', 'sftp2')

        when:

        def completeEvent2 = new ProgressCompleteEvent(startEvent2.progressOperationId, tenAm, "STATUS", false)