import org.gradle.internal.serialize.PlaceholderException
import spock.lang.Specification

class FullExceptionFormatterTest extends Specification {
    def testDescriptor = new SimpleTestDescriptor()
    def testLogging = Mock(TestLogging)
    def formatter = new FullExceptionFormatter(testLogging)

    def "shows all exceptions that have occurred for a test"() {
        expect:

    def workingDir = new File("some-dir")
    def projectCacheDir = new File("some-cache-dir")
    def options = Stub(DaemonForkOptions)
    def requirement = new ForkedWorkerRequirement(workingDir, projectCacheDir, options)
    def spec = Stub(IsolatedParametersActionExecutionSpec)

    def setup() {
        _ * buildOperationRunner.getCurrentOperation() >> buildOperation

    def setup() {
        file("settings.gradle") << 'rootProject.name="hello-world"'
    }

    def "models are streamed on build action cache hit"() {
        def listener1 = new TestStreamedValueListener()
        def listener2 = new TestStreamedValueListener()

        when:
        withIsolatedProjects()
        def model = runBuildAction(new ModelStreamingBuildAction()) {

class TransformProgressEventCrossVersionSpec extends ToolingApiSpecification {

    def events = ProgressEvents.create()

    def setup() {
        settingsFile << """
            include 'lib', 'app'
        """
        buildFile << """
            import org.gradle.api.artifacts.transform.TransformParameters

            def artifactType = Attribute.of('artifactType', String)
            subprojects {

            }

            def threaded(Closure action) {
                Thread.start(action).join()
            }
        """

        when:
        succeeds("all")

        then:
        10.times { projectCount ->
            def allExecutionOp = operations.only("Execute doLast {} action for :project-${projectCount}:all")
            def allExecutionOpTaskProgresses = allExecutionOp.progress

        "explicitly enabled"        | true
    }

    def "cleans up entries even if gradle user home cache cleanup is disabled via #cleanupMethod"() {
        def lastCleanupCheck = initializeHome()

        disableCacheCleanup(cleanupMethod)

        when:
        def newTrashFile = temporaryFolder.file("0" * hashStringLength).createFile()
        def oldTrashFile = temporaryFolder.file("1" * hashStringLength).createFile()

    TestFile rootMulti

    def setup() {
        rootSingle = singleProjectBuild("A")
        rootMulti = multiProjectBuild("B", ['x', 'y'])
    }

    @TargetGradleVersion(">=3.0")
    def "ProjectConnection provides identified models for single project build"() {
        when:
        def gradleProject = getModelWithProjectConnection(rootSingle, GradleProject)

    }

    def "uses #what toolchain #when (without java base plugin)"() {
        def currentJdk = Jvm.current()
        def otherJdk = AvailableJavaHomes.differentVersion
        def selectJdk = { it == "other" ? otherJdk : it == "current" ? currentJdk : null }

        def compileWithVersion = [currentJdk, otherJdk].collect { it.javaVersion }.min()

                void run() {
                    $taskActionMethodBody
                }
            }

            tasks.register("reportProblem", ProblemReportingTask)
        """
    }

    def runTask() {
        def listener = new ProblemProgressListener()
        withConnection { connection ->
            connection.newBuild().forTasks('reportProblem')
                .addProgressListener(listener)
                .run()

    private static final String REPOSITORY_ID = 'abc'
    def delegate = Mock(ModuleComponentRepositoryAccess)
    def repositoryBlacklister = Mock(RepositoryDisabler)

    @Shared
    def runtimeError = new RuntimeException('Something went wrong')
    @Shared
    def socketError = new SocketException()
    @Shared
    def connectTimeout = new SocketTimeoutException()
    @Shared
    def cannotConnect = new HttpHostConnectException(null, null)