// Log after all static init is finished; if an installed logger uses any Futures methods, it
    // shouldn't break in cases where reflection is missing/broken.
    if (thrownReflectionFailure != null) {
      log.get().log(Level.SEVERE, "SafeAtomicHelper is broken!", thrownReflectionFailure);
    }
  }

  AggregateFutureState(int remainingFutures) {
    this.remaining = remainingFutures;
  }

class CommandLineTaskExecutionIntegrationTest extends AbstractIntegrationSpec {
    def "fails with badly formed task name"() {
        createDirs("a")
        settingsFile """
            rootProject.name = 'broken'
            include("a")
        """
        buildFile """
        """

        when:
        fails(taskName)

        then:
        failure.assertHasDescription(message)

        where:

        def currentDist = createDistributionChecksumDir(GradleVersion.current()).parentFile

        def initDir = gradleUserHomeDir.createDir('init.d')
        initDir.createFile('broken.gradle') << """
            throw new Exception('BOOM!')
        """

        file('foo').createDir().createFile('settings.gradle')
        file('bar').createDir().createFile('settings.gradle')
        settingsFile << """

        buildSrc << """
            classes.doLast {
                throw new RuntimeException("broken")
            }
        """

        when:
        fails()

        then:
        failure.assertHasDescription("Execution failed for task ':buildSrc:classes'.")
        failure.assertHasCause("broken")

        where:
        settings                     | display

    @Test
    @ToBeFixedForConfigurationCache(because = "AntTarget task")
    void reportsAntTaskExecutionFailure() {
        testFile('build.xml') << """
<project>
    <target name='target1'>
        <fail>broken</fail>
    </target>
</project>
"""
        TestFile buildFile = testFile('build.gradle')
        buildFile << """
ant.importBuild('build.xml')
"""

 *
 * <p>Resolution happens in multiple steps. The first is to calculate the dependency graph, and the subsequent steps select artifacts. Artifact resolution is broken down into 3 main steps:</p>
 * <ul>
 *     <li>Select a variant of the component instance. The variant selected for artifact resolution may be different to that used for graph resolution,

    // Log after all static init is finished; if an installed logger uses any Futures methods, it
    // shouldn't break in cases where reflection is missing/broken.
    if (thrownReflectionFailure != null) {
      log.get().log(Level.SEVERE, "SafeAtomicHelper is broken!", thrownReflectionFailure);
    }
  }

  AggregateFutureState(int remainingFutures) {
    this.remaining = remainingFutures;
  }

import org.gradle.internal.file.FileType;
import org.gradle.internal.hash.HashCode;
import org.gradle.internal.hash.Hashing;

import java.util.Optional;

/**
 * A snapshot of a missing file or a broken symbolic link or a named pipe.
 */
public class MissingFileSnapshot extends AbstractFileSystemLocationSnapshot implements FileSystemLeafSnapshot {

    def "from-cache build fails when task action closure sets a project property"() {
        given:
        buildFile << """
            tasks.register("some") {
                doFirst {
                    description = "broken" // task property is ok
                    $expression = 1.2
                }
            }
        """

        when:
        configurationCacheFails ":some"

        then:

	g := NewWithT(t)

	store1 := memory.Make(collection.SchemasFor(schemaFor("SomeConfig", "broken message name")))

	stores := []model.ConfigStore{store1}

	store, err := makeStore(stores, nil)
	g.Expect(err).To(MatchError(ContainSubstring("not found: broken message name")))
	g.Expect(store).To(BeNil())
}

func TestAggregateStoreGet(t *testing.T) {
	g := NewWithT(t)